crewos 0.1.0

package/backend/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "crewos-backend",
+  "version": "0.1.0",
+  "type": "module",
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "dependencies": {
+    "@faker-js/faker": "^10.4.0",
+    "cors": "^2.8.6",
+    "express": "^5.2.1",
+    "lowdb": "^7.0.1"
+  },
+  "scripts": {
+    "dev": "node --watch src/index.js",
+    "start": "node src/index.js"
+  }
+}

package/backend/src/configs/db.config.js

@@ -0,0 +1,40 @@
+import path from 'path';
+import os from 'os';
+import { JSONFileSyncPreset } from 'lowdb/node';
+
+const DB_PATH = path.join(os.homedir(), '.crewos', 'db.json');
+
+const defaultData = {
+  members: [],
+  tasks: [],
+  meta: {
+    password: '',
+    baseURL: '',
+    apiKey: '',
+    model: 'auto',
+    models: [],
+    onboardingCompleted: false,
+    projectKnowledge: {
+      folderStructure: '',
+      techStack: '',
+      codingConventions: '',
+      databaseDesign: '',
+      apiDesign: '',
+      configSystem: '',
+      keyPatterns: '',
+      lastAnalyzed: null,
+    },
+  },
+};
+
+let db;
+
+export function initDB() {
+  db = JSONFileSyncPreset(DB_PATH, defaultData);
+  return db;
+}
+
+export function getDB() {
+  if (!db) throw new Error('Database not initialized. Call initDB() first.');
+  return db;
+}

package/backend/src/controllers/auth.controller.js

@@ -0,0 +1,19 @@
+import * as authService from '../services/auth.service.js';
+import { controllerCatcher } from '../utils/catcher.js';
+
+export const me = controllerCatcher((req, res) => {
+  const header = req.headers.authorization;
+
+  if (!header || !header.startsWith('Bearer '))
+    throw new Error('Bad credential');
+
+  const token = header.slice(7);
+
+  const verifyResult = authService.verifyPassword(token);
+  if (!verifyResult) throw new Error('Bad credential');
+
+  return res.json({
+    authenticated: true,
+    onboardingCompleted: verifyResult.onboardingCompleted || false,
+  });
+});

package/backend/src/controllers/config.controller.js

@@ -0,0 +1,23 @@
+import * as configService from '../services/config.service.js';
+import { controllerCatcher } from '../utils/catcher.js';
+
+export const getConfig = controllerCatcher((_req, res) => {
+  return res.json(configService.getConfig());
+});
+
+export const updateConfig = controllerCatcher(async (req, res) => {
+  const { password, baseURL, apiKey, model } = req.body;
+
+  const config = await configService.updateConfig({ password, baseURL, apiKey, model });
+  return res.json(config);
+});
+
+export const startReanalysis = controllerCatcher((_req, res) => {
+  const result = configService.startReanalysis();
+  if (result.error) return res.status(409).json({ error: result.error });
+  return res.json(result);
+});
+
+export const getReanalysisProgress = controllerCatcher((_req, res) => {
+  return res.json(configService.getReanalysisProgress());
+});

package/backend/src/controllers/member.controller.js

@@ -0,0 +1,30 @@
+import * as memberService from '../services/member.service.js';
+import { controllerCatcher } from '../utils/catcher.js';
+
+export const getAll = controllerCatcher((_req, res) => {
+  const members = memberService.getAll();
+  return res.json(members);
+});
+
+export const getById = controllerCatcher((req, res) => {
+  const member = memberService.getById(req.params.id);
+  if (!member) return res.status(404).json({ error: 'Member not found' });
+  return res.json(member);
+});
+
+export const create = controllerCatcher((req, res) => {
+  const member = memberService.create(req.body);
+  return res.status(201).json(member);
+});
+
+export const update = controllerCatcher((req, res) => {
+  const member = memberService.update(req.params.id, req.body);
+  if (!member) return res.status(404).json({ error: 'Member not found' });
+  return res.json(member);
+});
+
+export const remove = controllerCatcher((req, res) => {
+  const removed = memberService.remove(req.params.id);
+  if (!removed) return res.status(404).json({ error: 'Member not found' });
+  return res.sendStatus(204);
+});

package/backend/src/controllers/models.controller.js

@@ -0,0 +1,25 @@
+import { getDB } from '../configs/db.config.js';
+import { controllerCatcher } from '../utils/catcher.js';
+import { fetchModelsFromProvider } from '../services/config.service.js';
+
+export const fetchModels = controllerCatcher(async (req, res) => {
+  const db = getDB();
+  const { baseURL, apiKey } = req.body;
+
+  const url = baseURL || db.data.meta.baseURL;
+  const key = apiKey || db.data.meta.apiKey;
+
+  if (!url) {
+    return res.status(400).json({ message: 'Base URL is required' });
+  }
+  if (!key) {
+    return res.status(400).json({ message: 'API Key is required' });
+  }
+
+  try {
+    const models = await fetchModelsFromProvider(url, key);
+    return res.json(models);
+  } catch (err) {
+    return res.status(502).json({ message: err.message });
+  }
+});

package/backend/src/controllers/onboarding.controller.js

@@ -0,0 +1,49 @@
+import * as onboardingService from '../services/onboarding.service.js';
+import { controllerCatcher } from '../utils/catcher.js';
+
+export const getStatus = controllerCatcher((_req, res) => {
+  return res.json(onboardingService.getOnboardingStatus());
+});
+
+export const validate = controllerCatcher(async (req, res) => {
+  const { baseURL, apiKey } = req.body;
+
+  if (!baseURL) return res.status(400).json({ error: 'Base URL is required' });
+  if (!apiKey) return res.status(400).json({ error: 'API Key is required' });
+
+  try {
+    await onboardingService.validateCredentials(baseURL, apiKey);
+    return res.json({ valid: true });
+  } catch (err) {
+    return res.status(400).json({ error: err.message });
+  }
+});
+
+export const saveCredentials = controllerCatcher((req, res) => {
+  const { baseURL, apiKey } = req.body;
+
+  if (!baseURL) return res.status(400).json({ error: 'Base URL is required' });
+  if (!apiKey) return res.status(400).json({ error: 'API Key is required' });
+
+  onboardingService.saveCredentials(baseURL, apiKey);
+  return res.json({ success: true });
+});
+
+export const startAnalysis = controllerCatcher((_req, res) => {
+  const result = onboardingService.startAnalysis();
+  if (result.error) return res.status(409).json({ error: result.error });
+  return res.json(result);
+});
+
+export const getAnalysisProgress = controllerCatcher((_req, res) => {
+  return res.json({
+    lines: onboardingService.getAnalysisProgress(),
+    isAnalyzing: onboardingService.isAnalyzing(),
+  });
+});
+
+export const complete = controllerCatcher((_req, res) => {
+  const result = onboardingService.completeOnboarding();
+  if (result.error) return res.status(400).json({ error: result.error });
+  return res.json(result);
+});

package/backend/src/controllers/role.controller.js

@@ -0,0 +1,17 @@
+import * as roleService from '../services/role.service.js';
+import { controllerCatcher } from '../utils/catcher.js';
+
+export const getRoles = controllerCatcher((_req, res) => {
+  const roles = roleService.getRoles();
+  return res.json(roles);
+});
+
+export const pullRole = controllerCatcher((req, res) => {
+  const result = roleService.pullRole(req.params.roleId);
+
+  if (result.error) {
+    return res.status(400).json({ error: result.error });
+  }
+
+  return res.status(201).json(result);
+});

package/backend/src/controllers/task.controller.js

@@ -0,0 +1,63 @@
+import * as taskService from '../services/task.service.js';
+import { controllerCatcher } from '../utils/catcher.js';
+
+export const getAll = controllerCatcher((req, res) => {
+  const tasks = taskService.get({ status: req.query.status });
+  return res.json(tasks);
+});
+
+export const getById = controllerCatcher((req, res) => {
+  const task = taskService.getById(req.params.id);
+  if (!task) return res.status(404).json({ error: 'Task not found' });
+  return res.json(task);
+});
+
+export const create = controllerCatcher((req, res) => {
+  const result = taskService.create(req.body);
+  if (result.error) return res.status(400).json({ error: result.error });
+  return res.status(201).json(result);
+});
+
+export const update = controllerCatcher((req, res) => {
+  const task = taskService.update(req.params.id, req.body);
+  if (!task) return res.status(404).json({ error: 'Task not found' });
+  return res.json(task);
+});
+
+export const remove = controllerCatcher((req, res) => {
+  const removed = taskService.remove(req.params.id);
+  if (!removed) return res.status(404).json({ error: 'Task not found' });
+  return res.sendStatus(204);
+});
+
+export const start = controllerCatcher((req, res) => {
+  const result = taskService.startTask(req.params.id);
+  if (result.error) return res.status(409).json({ error: result.error });
+  return res.json(result);
+});
+
+export const getProgress = controllerCatcher((_req, res) => {
+  return res.json(taskService.getProgress());
+});
+
+export const stop = controllerCatcher((_req, res) => {
+  const result = taskService.stopTask();
+  if (result.error) return res.status(409).json({ error: result.error });
+  return res.json(result);
+});
+
+export const autoStart = controllerCatcher((req, res) => {
+  const result = taskService.startAutoDo(req.body.taskIds);
+  if (result.error) return res.status(409).json({ error: result.error });
+  return res.json(result);
+});
+
+export const autoStop = controllerCatcher((_req, res) => {
+  const result = taskService.stopAutoDo();
+  if (result.error) return res.status(409).json({ error: result.error });
+  return res.json(result);
+});
+
+export const autoStatus = controllerCatcher((_req, res) => {
+  return res.json(taskService.getAutoStatus());
+});

package/backend/src/index.js

@@ -0,0 +1,36 @@
+import path from 'path';
+import os from 'os';
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+import express from 'express';
+import cors from 'cors';
+import routes from './routes/index.js';
+import { initDB } from './configs/db.config.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+const db = initDB();
+
+const configPath = path.join(os.homedir(), '.crewos', 'config.json');
+let appConfig = { port: 3000 };
+if (fs.existsSync(configPath)) {
+  appConfig = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+}
+
+const app = express();
+
+app.use(cors());
+app.use(express.json());
+app.use('/api', routes);
+
+app.get('/', (req, res) => {
+  return res.sendStatus(200);
+});
+
+const PORT = process.env.PORT || appConfig.backendPort || 3000;
+
+app.listen(PORT, () => {
+  console.log(`crewOS running at http://localhost:${PORT}`);
+});
+
+export default app;

package/backend/src/middlewares/onboarding.guard.js

@@ -0,0 +1,14 @@
+import { getDB } from '../configs/db.config.js';
+
+export const onboardingGuard = (_req, res, next) => {
+  const db = getDB();
+
+  if (!db.data.meta.onboardingCompleted) {
+    return res.status(403).json({
+      error: 'Onboarding not completed',
+      onboardingRequired: true,
+    });
+  }
+
+  next();
+};

package/backend/src/routes/auth.route.js

@@ -0,0 +1,8 @@
+import { Router } from 'express';
+import * as authController from '../controllers/auth.controller.js';
+
+const router = Router();
+
+router.get('/me', authController.me);
+
+export default router;

package/backend/src/routes/config.route.js

@@ -0,0 +1,11 @@
+import { Router } from 'express';
+import * as configController from '../controllers/config.controller.js';
+
+const router = Router();
+
+router.get('/', configController.getConfig);
+router.put('/', configController.updateConfig);
+router.post('/analyze', configController.startReanalysis);
+router.get('/analyze/progress', configController.getReanalysisProgress);
+
+export default router;

package/backend/src/routes/index.js

@@ -0,0 +1,22 @@
+import { Router } from 'express';
+import taskRoute from './task.route.js';
+import memberRoute from './member.route.js';
+import roleRoute from './role.route.js';
+import configRoute from './config.route.js';
+import modelsRoute from './models.route.js';
+import authRoute from './auth.route.js';
+import onboardingRoute from './onboarding.route.js';
+import { onboardingGuard } from '../middlewares/onboarding.guard.js';
+
+const router = Router();
+
+router.use('/v1/auth', authRoute);
+router.use('/v1/onboarding', onboardingRoute);
+
+router.use('/v1/tasks', onboardingGuard, taskRoute);
+router.use('/v1/members', onboardingGuard, memberRoute);
+router.use('/v1/roles', onboardingGuard, roleRoute);
+router.use('/v1/config', onboardingGuard, configRoute);
+router.use('/v1/models', onboardingGuard, modelsRoute);
+
+export default router;

package/backend/src/routes/member.route.js

@@ -0,0 +1,11 @@
+import { Router } from 'express';
+import * as memberController from '../controllers/member.controller.js';
+
+const router = Router();
+
+router.get('/', memberController.getAll);
+router.get('/:id', memberController.getById);
+router.put('/:id', memberController.update);
+router.delete('/:id', memberController.remove);
+
+export default router;

package/backend/src/routes/models.route.js

@@ -0,0 +1,8 @@
+import { Router } from 'express';
+import { fetchModels } from '../controllers/models.controller.js';
+
+const router = Router();
+
+router.post('/', fetchModels);
+
+export default router;

package/backend/src/routes/onboarding.route.js

@@ -0,0 +1,13 @@
+import { Router } from 'express';
+import * as onboardingController from '../controllers/onboarding.controller.js';
+
+const router = Router();
+
+router.get('/status', onboardingController.getStatus);
+router.post('/validate', onboardingController.validate);
+router.post('/credentials', onboardingController.saveCredentials);
+router.post('/analyze', onboardingController.startAnalysis);
+router.get('/analyze/progress', onboardingController.getAnalysisProgress);
+router.post('/complete', onboardingController.complete);
+
+export default router;

package/backend/src/routes/role.route.js

@@ -0,0 +1,9 @@
+import { Router } from 'express';
+import * as roleController from '../controllers/role.controller.js';
+
+const router = Router();
+
+router.get('/', roleController.getRoles);
+router.post('/:roleId/pull', roleController.pullRole);
+
+export default router;

package/backend/src/routes/task.route.js

@@ -0,0 +1,20 @@
+import { Router } from 'express';
+import * as taskController from '../controllers/task.controller.js';
+
+const router = Router();
+
+router.get('/', taskController.getAll);
+
+router.get('/auto/status', taskController.autoStatus);
+router.post('/auto/start', taskController.autoStart);
+router.post('/auto/stop', taskController.autoStop);
+
+router.get('/progress', taskController.getProgress);
+router.get('/:id', taskController.getById);
+router.post('/', taskController.create);
+router.put('/:id', taskController.update);
+router.delete('/:id', taskController.remove);
+router.post('/stop', taskController.stop);
+router.post('/:id/start', taskController.start);
+
+export default router;

package/backend/src/services/auth.service.js

@@ -0,0 +1,14 @@
+import { getDB } from '../configs/db.config.js';
+
+export const verifyPassword = (token) => {
+  const db = getDB();
+  const password = db.data.meta.password;
+
+  if (!password) return false;
+  if (token !== password) return false;
+
+  return {
+    authenticated: true,
+    onboardingCompleted: db.data.meta.onboardingCompleted || false,
+  };
+};

package/backend/src/services/config.service.js

@@ -0,0 +1,176 @@
+import path from 'path';
+import os from 'os';
+import fs from 'fs';
+import { getDB } from '../configs/db.config.js';
+import { startAnalysis, getAnalysisProgress, isAnalyzing } from './onboarding.service.js';
+
+const CONFIG_PATH = path.join(os.homedir(), '.crewos', 'config.json');
+const OPENCODE_CONFIG_PATH = path.join(
+  os.homedir(),
+  '.config',
+  'opencode',
+  'opencode.json',
+);
+
+export const getCachedModels = () => {
+  const db = getDB();
+  return db.data.meta.models || [];
+};
+
+export const updateModelCache = (models) => {
+  const db = getDB();
+  db.data.meta.models = models || [];
+  db.write();
+  syncOpenCodeConfig();
+};
+
+const isModelValid = (model) => {
+  if (!model || model === 'auto') return true;
+  const cached = getCachedModels();
+  if (cached.length === 0) return true;
+  return cached.some((m) => m.id === model);
+};
+
+function readConfigFile() {
+  if (fs.existsSync(CONFIG_PATH)) {
+    return JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf-8'));
+  }
+  return {};
+}
+
+function readOpenCodeConfig() {
+  if (fs.existsSync(OPENCODE_CONFIG_PATH)) {
+    try {
+      return JSON.parse(fs.readFileSync(OPENCODE_CONFIG_PATH, 'utf-8'));
+    } catch {
+      return {};
+    }
+  }
+  return {};
+}
+
+function writeOpenCodeConfig(config) {
+  const dir = path.dirname(OPENCODE_CONFIG_PATH);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(OPENCODE_CONFIG_PATH, JSON.stringify(config, null, 2));
+}
+
+export const syncOpenCodeConfig = () => {
+  const db = getDB();
+  const { baseURL, apiKey, model } = db.data.meta;
+  const cached = getCachedModels();
+
+  if (!baseURL || !apiKey) return;
+
+  const effectiveModel = model && model !== 'auto' ? model : null;
+  const resolvedModelId =
+    effectiveModel || (cached.length > 0 ? cached[0].id : null);
+  if (!resolvedModelId) return;
+
+  const modelsMap = {};
+  for (const m of cached) {
+    modelsMap[m.id] = { id: m.id, name: m.name || m.id };
+  }
+
+  const existing = readOpenCodeConfig();
+  const providers = existing.provider || {};
+  providers.crewos = {
+    name: 'crewOS',
+    options: { baseURL, apiKey },
+    models: modelsMap,
+  };
+
+  writeOpenCodeConfig({
+    ...existing,
+    $schema: existing.$schema || 'https://opencode.ai/config.json',
+    provider: providers,
+    model: `crewos/${resolvedModelId}`,
+  });
+};
+
+export const fetchModelsFromProvider = async (baseURL, apiKey) => {
+  const normalizedBase = baseURL.replace(/\/+$/, '');
+  const modelsUrl = `${normalizedBase}/models`;
+
+  const response = await fetch(modelsUrl, {
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+      'Content-Type': 'application/json',
+    },
+  });
+
+  if (!response.ok) {
+    throw new Error(`Failed to fetch models: ${response.status}`);
+  }
+
+  const data = await response.json();
+  const models = (data.data || data).map((m) => ({
+    id: m.id || m.name || String(m),
+    name: m.id || m.name || String(m),
+  }));
+
+  updateModelCache(models);
+  return models;
+};
+
+export const getConfig = () => {
+  const db = getDB();
+  const fileConfig = readConfigFile();
+  return {
+    workingDir: fileConfig.workingDir || process.cwd(),
+    baseURL: db.data.meta.baseURL || '',
+    apiKey: db.data.meta.apiKey || '',
+    model: db.data.meta.model || 'auto',
+    password: db.data.meta.password || '',
+    models: getCachedModels(),
+    opencodePort: fileConfig.opencodePort,
+    onboardingCompleted: db.data.meta.onboardingCompleted || false,
+    projectKnowledge: db.data.meta.projectKnowledge || {},
+  };
+};
+
+export const updateConfig = async ({ password, baseURL, apiKey, model }) => {
+  const db = getDB();
+
+  if (password !== undefined) {
+    db.data.meta.password = password;
+  }
+  if (baseURL !== undefined) {
+    db.data.meta.baseURL = baseURL;
+  }
+  if (apiKey !== undefined) {
+    db.data.meta.apiKey = apiKey;
+  }
+  if (model !== undefined) {
+    db.data.meta.model = isModelValid(model) ? model : 'auto';
+  }
+
+  db.write();
+
+  const curBaseURL = baseURL !== undefined ? baseURL : db.data.meta.baseURL;
+  const curApiKey = apiKey !== undefined ? apiKey : db.data.meta.apiKey;
+
+  if (curBaseURL && curApiKey) {
+    try {
+      await fetchModelsFromProvider(curBaseURL, curApiKey);
+    } catch {
+      // non-fatal — models may already be in DB from a previous fetch
+    }
+  }
+
+  syncOpenCodeConfig();
+  return getConfig();
+};
+
+export const startReanalysis = () => {
+  return startAnalysis();
+};
+
+export const getReanalysisProgress = () => {
+  return {
+    lines: getAnalysisProgress(),
+    isAnalyzing: isAnalyzing(),
+  };
+};