myaidev-method 0.2.7 → 0.2.9

package/src/server/main.ts

@@ -0,0 +1,115 @@
+import { serve } from "@hono/node-server";
+import { Effect, ManagedRuntime } from "effect";
+import { NodeContext } from "@effect/platform-node";
+import { createApp } from "./hono/app.js";
+import { createAuthRoutes } from "./auth/routes/authRoutes.js";
+import { createAuthMiddleware } from "./auth/middleware/authMiddleware.js";
+import { createAppLayer } from "./auth/layers.js";
+import type { AppRuntimeContext } from "./auth/middleware/authMiddleware.js";
+import * as path from "node:path";
+import { homedir } from "node:os";
+
+const getDefaultDbPath = (): string => {
+  const sqliteDbPath = process.env["SQLITE_DB_PATH"];
+  if (sqliteDbPath) {
+    return sqliteDbPath;
+  }
+
+  if (process.env["SINGLE_USER_MODE"] === "true") {
+    const home = homedir();
+    return path.join(home, ".myaidev-web", "users.db");
+  }
+
+  return path.join(process.cwd(), "data", "users.db");
+};
+
+// Create the application layer with auth services
+const AppLayer = createAppLayer({
+  path: getDefaultDbPath(),
+  timeout: 5000,
+  verbose: false, // Disable verbose mode to prevent schema logging on every request
+});
+
+// Build the managed runtime once at startup (memoization with automatic scope management)
+const AppRuntime = ManagedRuntime.make(AppLayer) as ManagedRuntime.ManagedRuntime<AppRuntimeContext, never>;
+
+// Create middleware and routes with the memoized runtime
+const authMiddleware = createAuthMiddleware(AppRuntime);
+const authRouter = createAuthRoutes(AppRuntime, authMiddleware);
+
+const program = Effect.gen(function* () {
+  const port = Number.parseInt(process.env["PORT"] ?? "3400", 10);
+  const dbPath = getDefaultDbPath();
+
+  console.log(`🔧 Initializing MyAIDev Method Web Server`);
+  console.log(`📂 Database path: ${dbPath}`);
+  console.log(`🌐 Server port: ${port}`);
+  console.log(`✅ Application layer initialized successfully`);
+
+  const app = createApp();
+
+  console.log(`🚀 Starting server on port ${port}...`);
+
+  // Mount authentication routes (already created with AppLayer)
+  app.route("/api/auth", authRouter);
+
+  // Example protected route
+  app.get("/api/protected", authMiddleware, (c) => {
+    const user = c.get("user");
+    const session = c.get("session");
+
+    return c.json({
+      message: "This is a protected route",
+      user: {
+        id: user?.id,
+        username: user?.username,
+        email: user?.email,
+      },
+      session: {
+        id: session?.id,
+        expiresAt: session?.expiresAt,
+      },
+    });
+  });
+
+  console.log("✅ Routes configured successfully");
+  console.log("   📍 POST /api/auth/register - User registration");
+  console.log("   📍 POST /api/auth/login - User login");
+  console.log("   📍 POST /api/auth/logout - User logout (protected)");
+  console.log("   📍 GET  /api/auth/me - Current user info (protected)");
+  console.log("   📍 GET  /api/protected - Example protected route");
+
+  const server = serve({
+    fetch: app.fetch,
+    port,
+  });
+
+  console.log(`✅ Server running at http://localhost:${port}`);
+  console.log(`📊 Health check: http://localhost:${port}/health`);
+
+  yield* Effect.async<void, never>(() => {
+    process.on("SIGTERM", () => {
+      console.log("\n🛑 SIGTERM received, shutting down gracefully...");
+      server.close(() => {
+        console.log("✅ Server closed");
+        process.exit(0);
+      });
+    });
+
+    process.on("SIGINT", () => {
+      console.log("\n🛑 SIGINT received, shutting down gracefully...");
+      server.close(() => {
+        console.log("✅ Server closed");
+        process.exit(0);
+      });
+    });
+  });
+});
+
+// Program only needs Node context
+Effect.runPromise(
+  Effect.provide(program, NodeContext.layer) as Effect.Effect<void, never, never>
+).catch((error) => {
+  console.error("❌ Fatal error:", error);
+  process.exit(1);
+});

package/src/server/user-management/DirectoryService.ts

@@ -0,0 +1,348 @@
+import { Effect, Context, Layer } from "effect";
+import { execSync } from "child_process";
+import * as fs from "fs/promises";
+import * as path from "path";
+
+/**
+ * Directory Management Service
+ *
+ * Handles creation and management of user home directories,
+ * Claude Code configurations, and workspace setup for isolated
+ * multi-user environments.
+ *
+ * Directory Structure:
+ * /home/{username}/
+ * ├── .claude/              # Claude Code configuration
+ * │   ├── config.json       # User-specific Claude settings
+ * │   ├── sessions/         # Session storage
+ * │   └── cache/            # Cache directory
+ * ├── workspace/            # User's workspace directory
+ * └── .bashrc               # Shell configuration
+ */
+
+export interface DirectorySetupOptions {
+  username: string;
+  homeDir: string;
+  uid: number;
+  gid: number;
+  claudeConfig?: ClaudeConfig;
+}
+
+export interface ClaudeConfig {
+  apiKey?: string;
+  model?: string;
+  maxTokens?: number;
+  temperature?: number;
+}
+
+export interface DirectoryError {
+  readonly _tag: "DirectoryError";
+  readonly message: string;
+  readonly cause?: unknown;
+}
+
+const DirectoryError = (message: string, cause?: unknown): DirectoryError => ({
+  _tag: "DirectoryError",
+  message,
+  cause,
+});
+
+export class DirectoryService extends Context.Tag("DirectoryService")<
+  DirectoryService,
+  {
+    /**
+     * Set up complete home directory structure for a user
+     */
+    readonly setupHomeDirectory: (
+      options: DirectorySetupOptions
+    ) => Effect.Effect<void, DirectoryError>;
+
+    /**
+     * Create Claude Code configuration directory
+     */
+    readonly createClaudeConfig: (
+      homeDir: string,
+      config: ClaudeConfig,
+      uid: number,
+      gid: number
+    ) => Effect.Effect<void, DirectoryError>;
+
+    /**
+     * Create user workspace directory
+     */
+    readonly createWorkspace: (
+      homeDir: string,
+      uid: number,
+      gid: number
+    ) => Effect.Effect<void, DirectoryError>;
+
+    /**
+     * Set proper ownership and permissions
+     */
+    readonly setOwnership: (
+      dirPath: string,
+      uid: number,
+      gid: number,
+      recursive?: boolean
+    ) => Effect.Effect<void, DirectoryError>;
+
+    /**
+     * Clean up user directories
+     */
+    readonly cleanupDirectories: (
+      homeDir: string
+    ) => Effect.Effect<void, DirectoryError>;
+  }
+>() {
+  static Live = Layer.succeed(this, {
+    setupHomeDirectory: (options: DirectorySetupOptions) =>
+      Effect.gen(function* () {
+        const { username, homeDir, uid, gid, claudeConfig } = options;
+
+        // Ensure home directory exists (should be created by useradd)
+        yield* Effect.tryPromise({
+          try: async () => {
+            await fs.access(homeDir);
+          },
+          catch: (error) =>
+            DirectoryError(
+              `Home directory ${homeDir} does not exist. Create user first.`,
+              error
+            ),
+        });
+
+        // Create .claude directory
+        const claudeDir = path.join(homeDir, ".claude");
+        yield* Effect.tryPromise({
+          try: async () => {
+            await fs.mkdir(claudeDir, { recursive: true, mode: 0o755 });
+          },
+          catch: (error) =>
+            DirectoryError(`Failed to create .claude directory`, error),
+        });
+
+        // Create subdirectories
+        const subdirs = ["sessions", "cache", "workspace"];
+        for (const subdir of subdirs) {
+          const subdirPath =
+            subdir === "workspace"
+              ? path.join(homeDir, subdir)
+              : path.join(claudeDir, subdir);
+
+          yield* Effect.tryPromise({
+            try: async () => {
+              await fs.mkdir(subdirPath, { recursive: true, mode: 0o755 });
+            },
+            catch: (error) =>
+              DirectoryError(`Failed to create ${subdir} directory`, error),
+          });
+        }
+
+        // Create Claude config file
+        if (claudeConfig) {
+          const configPath = path.join(claudeDir, "config.json");
+          const configContent = JSON.stringify(
+            {
+              apiKey: claudeConfig.apiKey || "",
+              model: claudeConfig.model || "claude-sonnet-4-20250514",
+              maxTokens: claudeConfig.maxTokens || 8192,
+              temperature: claudeConfig.temperature || 1.0,
+              username,
+              createdAt: new Date().toISOString(),
+            },
+            null,
+            2
+          );
+
+          yield* Effect.tryPromise({
+            try: async () => {
+              await fs.writeFile(configPath, configContent, {
+                mode: 0o600,
+              });
+            },
+            catch: (error) =>
+              DirectoryError("Failed to create Claude config file", error),
+          });
+        }
+
+        // Create .bashrc with helpful aliases
+        const bashrcPath = path.join(homeDir, ".bashrc");
+        const bashrcContent = `# MyAIDev Method User Environment
+# Generated on ${new Date().toISOString()}
+
+# Helpful aliases
+alias ll='ls -alh'
+alias workspace='cd ~/workspace'
+alias claude='cd ~/.claude'
+
+# Environment
+export PATH="$HOME/.local/bin:$PATH"
+export CLAUDE_CONFIG_DIR="$HOME/.claude"
+
+# Workspace directory
+export WORKSPACE="$HOME/workspace"
+
+# Welcome message
+echo "Welcome to MyAIDev Method, ${username}!"
+echo "Your workspace is in: ~/workspace"
+`;
+
+        yield* Effect.tryPromise({
+          try: async () => {
+            await fs.writeFile(bashrcPath, bashrcContent, { mode: 0o644 });
+          },
+          catch: (error) =>
+            DirectoryError("Failed to create .bashrc file", error),
+        });
+
+        // Set ownership of all created files/directories
+        yield* Effect.tryPromise({
+          try: async () => {
+            execSync(`sudo chown -R ${uid}:${gid} ${homeDir}`, {
+              stdio: "pipe",
+            });
+          },
+          catch: (error) =>
+            DirectoryError(
+              `Failed to set ownership for ${homeDir}`,
+              error
+            ),
+        });
+
+        // Set proper permissions
+        yield* Effect.tryPromise({
+          try: async () => {
+            execSync(`sudo chmod 755 ${homeDir}`, { stdio: "pipe" });
+            execSync(`sudo chmod 700 ${claudeDir}`, { stdio: "pipe" });
+            execSync(`sudo chmod 755 ${path.join(homeDir, "workspace")}`, {
+              stdio: "pipe",
+            });
+          },
+          catch: (error) =>
+            DirectoryError("Failed to set directory permissions", error),
+        });
+      }),
+
+    createClaudeConfig: (
+      homeDir: string,
+      config: ClaudeConfig,
+      uid: number,
+      gid: number
+    ) =>
+      Effect.gen(function* () {
+        const claudeDir = path.join(homeDir, ".claude");
+        const configPath = path.join(claudeDir, "config.json");
+
+        // Ensure .claude directory exists
+        yield* Effect.tryPromise({
+          try: async () => {
+            await fs.mkdir(claudeDir, { recursive: true, mode: 0o700 });
+          },
+          catch: (error) =>
+            DirectoryError("Failed to create .claude directory", error),
+        });
+
+        // Write config file
+        const configContent = JSON.stringify(config, null, 2);
+        yield* Effect.tryPromise({
+          try: async () => {
+            await fs.writeFile(configPath, configContent, { mode: 0o600 });
+          },
+          catch: (error) =>
+            DirectoryError("Failed to write Claude config", error),
+        });
+
+        // Set ownership
+        yield* Effect.tryPromise({
+          try: async () => {
+            execSync(`sudo chown -R ${uid}:${gid} ${claudeDir}`, {
+              stdio: "pipe",
+            });
+          },
+          catch: (error) =>
+            DirectoryError("Failed to set config ownership", error),
+        });
+      }),
+
+    createWorkspace: (homeDir: string, uid: number, gid: number) =>
+      Effect.gen(function* () {
+        const workspaceDir = path.join(homeDir, "workspace");
+
+        // Create workspace directory
+        yield* Effect.tryPromise({
+          try: async () => {
+            await fs.mkdir(workspaceDir, { recursive: true, mode: 0o755 });
+          },
+          catch: (error) =>
+            DirectoryError("Failed to create workspace directory", error),
+        });
+
+        // Create a README file
+        const readmePath = path.join(workspaceDir, "README.md");
+        const readmeContent = `# Welcome to Your MyAIDev Method Workspace
+
+This is your personal workspace for AI-assisted development with Claude Code.
+
+## Directory Structure
+
+- Use this workspace to create and manage your projects
+- Claude Code will have access to files in this directory
+- Your work is isolated from other users
+
+## Getting Started
+
+1. Create a new project directory
+2. Initialize your project (git init, npm init, etc.)
+3. Start working with Claude Code assistance
+
+Happy coding!
+`;
+
+        yield* Effect.tryPromise({
+          try: async () => {
+            await fs.writeFile(readmePath, readmeContent, { mode: 0o644 });
+          },
+          catch: (error) =>
+            DirectoryError("Failed to create workspace README", error),
+        });
+
+        // Set ownership
+        yield* Effect.tryPromise({
+          try: async () => {
+            execSync(`sudo chown -R ${uid}:${gid} ${workspaceDir}`, {
+              stdio: "pipe",
+            });
+          },
+          catch: (error) =>
+            DirectoryError("Failed to set workspace ownership", error),
+        });
+      }),
+
+    setOwnership: (
+      dirPath: string,
+      uid: number,
+      gid: number,
+      recursive: boolean = false
+    ) =>
+      Effect.tryPromise({
+        try: async () => {
+          const recursiveFlag = recursive ? "-R" : "";
+          execSync(`sudo chown ${recursiveFlag} ${uid}:${gid} ${dirPath}`, {
+            stdio: "pipe",
+          });
+        },
+        catch: (error) =>
+          DirectoryError(`Failed to set ownership for ${dirPath}`, error),
+      }),
+
+    cleanupDirectories: (homeDir: string) =>
+      Effect.tryPromise({
+        try: async () => {
+          // Remove home directory and all contents
+          execSync(`sudo rm -rf ${homeDir}`, { stdio: "pipe" });
+        },
+        catch: (error) =>
+          DirectoryError(`Failed to cleanup directories for ${homeDir}`, error),
+      }),
+  });
+}