devglide 0.1.1

package/bin/devglide.js

@@ -0,0 +1,387 @@
+#!/usr/bin/env node
+
+import { spawn, execSync } from "child_process";
+import { resolve, dirname } from "path";
+import { fileURLToPath } from "url";
+import { mkdirSync, writeFileSync, readFileSync, unlinkSync, existsSync, openSync, closeSync } from "fs";
+
+import { homedir } from "os";
+
+import { getClaudeMdContent, injectSection, removeSection } from "./claude-md-template.js";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const root = resolve(__dirname, "..");
+const stateDir = resolve(homedir(), ".devglide");
+const pidDir = resolve(stateDir, "pids");
+const logDir = resolve(stateDir, "logs");
+
+mkdirSync(pidDir, { recursive: true });
+mkdirSync(logDir, { recursive: true });
+
+// Unified server (single process, all apps on one port)
+const SERVER_PORT = 7000;
+
+const [command, ...args] = process.argv.slice(2);
+
+// --- PID helpers ---
+
+function pidFile(name) {
+  return resolve(pidDir, `${name}.pid`);
+}
+
+function savePid(name, pid) {
+  writeFileSync(pidFile(name), String(pid));
+}
+
+function readPid(name) {
+  try {
+    return parseInt(readFileSync(pidFile(name), "utf8"), 10);
+  } catch {
+    return null;
+  }
+}
+
+function removePid(name) {
+  try { unlinkSync(pidFile(name)); } catch {}
+}
+
+function isRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function getStatus(name) {
+  const pid = readPid(name);
+  if (pid && isRunning(pid)) return { running: true, pid };
+  if (pid) removePid(name); // stale pid
+  return { running: false, pid: null };
+}
+
+// --- Commands ---
+
+function showStatus() {
+  console.log();
+  const { running, pid } = getStatus("server");
+  const state = running ? `\x1b[32mrunning\x1b[0m  pid ${pid}` : `\x1b[90mstopped\x1b[0m`;
+  console.log(`  server  :${SERVER_PORT}  ${state}`);
+  console.log();
+}
+
+function tailLogs(name) {
+  const logFile = resolve(logDir, `${name}.log`);
+  if (!existsSync(logFile)) {
+    console.error(`No logs for ${name}`);
+    process.exit(1);
+  }
+  const tail = spawn("tail", ["-f", "-n", "50", logFile], { stdio: "inherit" });
+  process.on("SIGINT", () => { tail.kill(); process.exit(0); });
+}
+
+// --- MCP launcher ---
+
+const mcpServers = {
+  kanban:     { cwd: "src/apps/kanban",     entry: "src/index.ts", runtime: "tsx" },
+  voice:      { cwd: "src/apps/voice",      entry: "src/index.ts", runtime: "tsx" },
+  log:        { cwd: "src/apps/log",        entry: "src/index.ts", runtime: "tsx" },
+  test:       { cwd: "src/apps/test",       entry: "src/index.ts", runtime: "tsx" },
+  shell:      { cwd: "src/apps/shell",      entry: "src/index.ts", runtime: "tsx" },
+  workflow:   { cwd: "src/apps/workflow",   entry: "src/index.ts", runtime: "tsx" },
+  vocabulary: { cwd: "src/apps/vocabulary", entry: "src/index.ts", runtime: "tsx" },
+  prompts:    { cwd: "src/apps/prompts",    entry: "src/index.ts", runtime: "tsx" },
+};
+
+function runMcpServer(name) {
+  const server = mcpServers[name];
+  if (!server) {
+    console.error(`Unknown MCP server: ${name}`);
+    console.error(`Available: ${Object.keys(mcpServers).join(", ")}`);
+    process.exit(1);
+  }
+
+  const cwd = resolve(root, server.cwd);
+  const entry = resolve(cwd, server.entry);
+
+  if (server.runtime === "tsx") {
+    const tsxPaths = [
+      resolve(root, "node_modules/.bin/tsx"),
+      resolve(cwd, "node_modules/.bin/tsx"),
+    ];
+    const tsxBin = tsxPaths.find((p) => existsSync(p));
+
+    if (!tsxBin) {
+      console.error("tsx not found. Run 'pnpm install' first.");
+      process.exit(1);
+    }
+
+    const child = spawn(tsxBin, [entry, "--stdio"], {
+      cwd,
+      stdio: "inherit",
+      env: process.env,
+      shell: true,
+    });
+    child.on("exit", (code) => process.exit(code ?? 1));
+  } else {
+    const child = spawn(process.execPath, [entry, "--stdio"], {
+      cwd,
+      stdio: "inherit",
+      env: process.env,
+    });
+    child.on("exit", (code) => process.exit(code ?? 1));
+  }
+}
+
+// --- Unified server ---
+
+function startServer(foreground = false) {
+  const { running, pid } = getStatus("server");
+  if (running) {
+    console.log(`  server already running (pid ${pid})`);
+    return;
+  }
+
+  const tsxBin = resolve(root, "node_modules/.bin/tsx");
+  if (!existsSync(tsxBin)) {
+    console.error("tsx not found. Run 'pnpm install' first.");
+    process.exit(1);
+  }
+
+  if (foreground) {
+    const child = spawn(tsxBin, ["src/server.ts"], {
+      cwd: root,
+      stdio: "inherit",
+      env: { ...process.env, PORT: String(SERVER_PORT) },
+      shell: true,
+    });
+    child.on("exit", (code) => process.exit(code ?? 1));
+    return;
+  }
+
+  // Background daemon
+  const logFile = resolve(logDir, "server.log");
+  const out = openSync(logFile, "a");
+  const child = spawn(tsxBin, ["src/server.ts"], {
+    cwd: root,
+    stdio: ["ignore", out, out],
+    env: { ...process.env, PORT: String(SERVER_PORT) },
+    detached: true,
+    shell: true,
+  });
+  savePid("server", child.pid);
+  child.unref();
+  closeSync(out);
+  console.log(`  server started on :${SERVER_PORT} (pid ${child.pid})`);
+}
+
+function killTree(pid, signal) {
+  try { process.kill(-pid, signal); } catch {
+    try { process.kill(pid, signal); } catch {}
+  }
+}
+
+function stopServer() {
+  const { running, pid } = getStatus("server");
+  if (!running) {
+    console.log("  server not running");
+    return;
+  }
+  killTree(pid, "SIGTERM");
+  setTimeout(() => {
+    if (isRunning(pid)) killTree(pid, "SIGKILL");
+  }, 5000).unref();
+  removePid("server");
+  console.log(`  server stopped (was pid ${pid})`);
+}
+
+// --- Setup ---
+
+function runSetup() {
+  console.log("\n  Setting up DevGlide...\n");
+
+  const devglideBin = resolve(__dirname, "devglide.js");
+
+  console.log("  Registering MCP servers in Claude Code...\n");
+
+  let failed = false;
+  for (const name of Object.keys(mcpServers)) {
+    const mcpName = `devglide-${name}`;
+    try {
+      // Remove existing registration if any
+      try {
+        execSync(`claude mcp remove ${mcpName} --scope user`, { stdio: "pipe" });
+      } catch {
+        // Not registered yet — that's fine
+      }
+      execSync(
+        `claude mcp add --transport stdio ${mcpName} --scope user -- ${process.execPath} ${devglideBin} mcp ${name}`,
+        { stdio: "inherit" }
+      );
+      console.log(`  ✓ ${mcpName} registered globally`);
+    } catch {
+      console.error(`  ✗ ${mcpName} failed to register`);
+      failed = true;
+    }
+  }
+
+  if (failed) {
+    console.error("\n  Some servers failed to register. Is Claude Code (CLI) installed?");
+    process.exit(1);
+  }
+
+  // Install managed CLAUDE.md section
+  const claudeDir = resolve(homedir(), ".claude");
+  const claudeMdPath = resolve(claudeDir, "CLAUDE.md");
+  mkdirSync(claudeDir, { recursive: true });
+
+  let existing = "";
+  try {
+    existing = readFileSync(claudeMdPath, "utf8");
+  } catch {
+    // File doesn't exist yet
+  }
+
+  const updated = injectSection(existing, getClaudeMdContent());
+  if (updated !== existing) {
+    writeFileSync(claudeMdPath, updated);
+    console.log(`\n  ✓ DevGlide instructions installed in ${claudeMdPath}`);
+  } else {
+    console.log(`\n  ✓ DevGlide instructions already up to date in ${claudeMdPath}`);
+  }
+
+  console.log("\n  Setup complete!\n");
+}
+
+function runTeardown() {
+  console.log("\n  Tearing down DevGlide...\n");
+
+  // Remove MCP server registrations
+  for (const name of Object.keys(mcpServers)) {
+    const mcpName = `devglide-${name}`;
+    try {
+      execSync(`claude mcp remove ${mcpName} --scope user`, { stdio: "pipe" });
+      console.log(`  ✓ ${mcpName} removed`);
+    } catch {
+      console.log(`  - ${mcpName} was not registered`);
+    }
+  }
+
+  // Remove managed CLAUDE.md section
+  const claudeMdPath = resolve(homedir(), ".claude", "CLAUDE.md");
+  try {
+    const existing = readFileSync(claudeMdPath, "utf8");
+    const updated = removeSection(existing);
+    if (updated !== existing) {
+      if (updated.trim().length === 0) {
+        unlinkSync(claudeMdPath);
+        console.log(`\n  ✓ Removed ${claudeMdPath} (was empty)`);
+      } else {
+        writeFileSync(claudeMdPath, updated);
+        console.log(`\n  ✓ DevGlide instructions removed from ${claudeMdPath}`);
+      }
+    } else {
+      console.log(`\n  - No DevGlide instructions found in ${claudeMdPath}`);
+    }
+  } catch {
+    console.log(`\n  - ${claudeMdPath} not found`);
+  }
+
+  console.log("\n  Teardown complete!\n");
+}
+
+function usage() {
+  console.log(`
+  devglide — development workflow toolkit
+
+  Usage:
+    devglide start           Start server as background daemon
+    devglide stop            Stop server
+    devglide restart         Restart server
+    devglide dev             Run server in foreground (recommended for development)
+    devglide status          Show running status
+    devglide logs            Tail server logs
+    devglide mcp <server>    Launch a single MCP server on stdio
+    devglide setup           Register MCP servers + install CLAUDE.md instructions
+    devglide teardown        Unregister MCP servers + remove CLAUDE.md instructions
+
+  Server:
+    All apps on :${SERVER_PORT} (single process)
+
+  MCP servers:
+${Object.keys(mcpServers).map((name) => `    ${name}`).join("\n")}
+
+  State: ~/.devglide/  (pids, logs)
+`);
+}
+
+switch (command) {
+  case "dev":
+    startServer(true);
+    break;
+
+  case "start":
+  case "server":
+    if (args[0] === "stop") {
+      stopServer();
+    } else {
+      startServer(command === "dev");
+    }
+    break;
+
+  case "stop":
+    stopServer();
+    break;
+
+  case "restart":
+    stopServer();
+    // Brief wait for port to free
+    setTimeout(() => startServer(false), 1000);
+    break;
+
+  case "status":
+    showStatus();
+    break;
+
+  case "logs":
+    tailLogs("server");
+    break;
+
+  case "list":
+    console.log("\nMCP servers:\n");
+    for (const name of Object.keys(mcpServers)) {
+      console.log(`  ${name}`);
+    }
+    console.log();
+    break;
+
+  case "mcp": {
+    if (!args[0]) {
+      console.error(`Usage: devglide mcp <server>\nAvailable: ${Object.keys(mcpServers).join(", ")}`);
+      process.exit(1);
+    }
+    runMcpServer(args[0]);
+    break;
+  }
+
+  case "setup":
+    runSetup();
+    break;
+
+  case "teardown":
+    runTeardown();
+    break;
+
+  case "help":
+  case "--help":
+  case "-h":
+  case undefined:
+    usage();
+    break;
+
+  default:
+    console.error(`Unknown command: ${command}`);
+    usage();
+    process.exit(1);
+}

package/package.json

@@ -0,0 +1,85 @@
+{
+  "name": "devglide",
+  "version": "0.1.1",
+  "description": "AI workflow toolkit with MCP servers for kanban, shell, testing, workflows, and more — built for Claude Code",
+  "license": "MIT",
+  "author": "Daniel Kutyla",
+  "type": "module",
+  "packageManager": "pnpm@10.30.3",
+  "engines": {
+    "node": ">=22"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/DannyNs/devglide.git"
+  },
+  "homepage": "https://github.com/DannyNs/devglide#readme",
+  "bugs": {
+    "url": "https://github.com/DannyNs/devglide/issues"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "claude-code",
+    "developer-tools",
+    "ai-workflow",
+    "kanban",
+    "terminal",
+    "test-automation",
+    "cli"
+  ],
+  "bin": {
+    "devglide": "./bin/devglide.js"
+  },
+  "files": [
+    "bin/",
+    "src/apps/",
+    "src/packages/",
+    "turbo.json",
+    "pnpm-workspace.yaml"
+  ],
+  "scripts": {
+    "dev": "turbo dev --concurrency 20",
+    "dev:server": "tsx src/server.ts",
+    "build": "turbo build",
+    "lint": "turbo lint",
+    "typecheck": "turbo typecheck",
+    "test": "vitest run",
+    "clean": "turbo clean && rm -rf node_modules"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.1",
+    "@paralleldrive/cuid2": "^2.3.1",
+    "better-sqlite3": "^11.10.0",
+    "chokidar": "^4.0.3",
+    "cors": "^2.8.6",
+    "express": "^5.2.1",
+    "multer": "1.4.5-lts.2",
+    "node-pty": "^1.1.0",
+    "openai": "^4.104.0",
+    "socket.io": "^4.8.3",
+    "socket.io-client": "^4.8.3",
+    "uuid": "^11.1.0",
+    "zod": "^3.25.49"
+  },
+  "devDependencies": {
+    "@devglide/eslint-config": "workspace:*",
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/cors": "^2.8.19",
+    "@types/express": "^5.0.0",
+    "@types/multer": "^1.4.13",
+    "@types/node": "^22.0.0",
+    "eslint": "^9.39.4",
+    "tsx": "^4.19.0",
+    "turbo": "^2.5.0",
+    "typescript": "^5.8.0",
+    "vitest": "^4.1.0"
+  },
+  "pnpm": {
+    "onlyBuiltDependencies": [
+      "esbuild",
+      "node-pty",
+      "better-sqlite3"
+    ]
+  }
+}

package/pnpm-workspace.yaml

@@ -0,0 +1,3 @@
+packages:
+  - "src/apps/*"
+  - "src/packages/*"

package/src/apps/coder/.turbo/turbo-lint.log

@@ -0,0 +1,5 @@
+ WARN  Issue while reading "/home/runner/_work/devglide/devglide/.npmrc". Failed to replace env in config: ${NODE_AUTH_TOKEN}
+
+> @devglide/coder@0.1.0 lint /home/runner/_work/devglide/devglide/src/apps/coder
+> eslint .
+

package/src/apps/coder/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@devglide/coder",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "In-browser IDE for viewing and editing monorepo files",
+  "main": "server.js",
+  "scripts": {
+    "dev": "node --watch server.js",
+    "start": "node server.js",
+    "lint": "eslint ."
+  },
+  "private": true,
+  "dependencies": {
+    "express": "^5.2.1"
+  }
+}

package/src/apps/coder/public/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>