@tyvm/knowhow 0.0.55 → 0.0.56

package/src/worker.ts

@@ -7,15 +7,141 @@ import { McpServerService } from "./services/Mcp";
 import * as allTools from "./agents/tools";
 import { wait } from "./utils";
 import { getConfig, updateConfig } from "./config";
+import { KNOWHOW_API_URL } from "./services/KnowhowClient";
+import { registerWorkerPath } from "./workerRegistry";
 
-const API_URL = process.env.KNOWHOW_API_URL;
+const API_URL = KNOWHOW_API_URL;
+
+/**
+ * Run the worker in a Docker sandbox
+ */
+async function runWorkerInSandbox(
+  options: { share?: boolean; unshare?: boolean; sandbox?: boolean },
+  config: any
+) {
+  const { Docker } = services();
+
+  console.log("🐳 Starting knowhow worker in Docker sandbox mode...\n");
+
+  // Check if Docker is available
+  const dockerAvailable = await Docker.checkDockerAvailable();
+
+  if (!dockerAvailable) {
+    console.error("❌ Docker is not installed or not running.");
+    console.error("\nTo use --sandbox mode, you need to:");
+    console.error("  1. Install Docker: https://docs.docker.com/get-docker/");
+    console.error("  2. Start the Docker daemon");
+    console.error("  3. Run this command again with --sandbox\n");
+    process.exit(1);
+  }
+
+  console.log("✓ Docker is available");
+
+  // Always rebuild the image to ensure it's up to date with any Dockerfile changes
+  console.log("🔄 Building Docker image (ensuring latest version)...");
+  try {
+    await Docker.buildWorkerImage();
+  } catch (error) {
+    console.error("❌ Failed to build Docker image:", error.message);
+    console.error("\nPlease check the .knowhow/Dockerfile.worker for errors");
+    console.error("  You can edit this file to customize the worker image\n");
+    process.exit(1);
+  }
+
+  // Get JWT token
+  const jwt = await loadJwt();
+
+  // Run the container
+  let containerId: string;
+
+  console.log("🚀 Starting Docker container...");
+  try {
+    containerId = await Docker.runWorkerContainer({
+      workspaceDir: process.cwd(),
+      jwt,
+      apiUrl: API_URL,
+      config,
+      share: options?.share,
+      unshare: options?.unshare,
+    });
+  } catch (error) {
+    console.error("❌ Failed to start Docker container:", error.message);
+    process.exit(1);
+  }
+
+  // Follow logs and handle cleanup
+  try {
+    await Docker.followContainerLogs(containerId);
+  } finally {
+    await Docker.stopContainer(containerId);
+  }
+}
+
+export async function worker(options?: {
+  register?: boolean;
+  share?: boolean;
+  unshare?: boolean;
+  sandbox?: boolean;
+  noSandbox?: boolean;
+}) {
+  const config = await getConfig();
+
+  // Determine sandbox mode with priority: command line flags > config > default (false)
+  let shouldUseSandbox = false;
+  let sandboxSource = "";
+
+  if (options?.sandbox) {
+    shouldUseSandbox = true;
+    sandboxSource = "command line (--sandbox)";
+
+    // Save sandbox preference to config
+    const updatedConfig = {
+      ...config,
+      worker: {
+        ...config.worker,
+        sandbox: true,
+      },
+    };
+    await updateConfig(updatedConfig);
+    console.log("💾 Sandbox mode preference saved to config");
+  } else if (options?.noSandbox) {
+    shouldUseSandbox = false;
+    sandboxSource = "command line (--no-sandbox)";
+
+    // Save no-sandbox preference to config
+    const updatedConfig = {
+      ...config,
+      worker: {
+        ...config.worker,
+        sandbox: false,
+      },
+    };
+    await updateConfig(updatedConfig);
+    console.log("💾 No-sandbox mode preference saved to config");
+  } else {
+    // Use config preference or default to false
+    shouldUseSandbox = config.worker?.sandbox ?? false;
+    sandboxSource =
+      config.worker?.sandbox !== undefined
+        ? `config (${shouldUseSandbox ? "sandbox" : "no-sandbox"})`
+        : "default (no-sandbox)";
+  }
+
+  if (shouldUseSandbox) {
+    console.log(`🐳 Using sandbox mode (${sandboxSource})`);
+    return runWorkerInSandbox(options, config);
+  }
 
-export async function worker() {
   const { Tools } = services();
   const mcpServer = new McpServerService(Tools);
   const clientName = "knowhow-worker";
   const clientVersion = "1.1.1";
-  const config = await getConfig();
+
+  if (!shouldUseSandbox) {
+    console.log(`🖥️  Using host mode (${sandboxSource})`);
+  }
+
+  // Use the config we already loaded above
 
   if (!config.worker || !config.worker.allowedTools) {
     console.log(
@@ -30,6 +156,12 @@ export async function worker() {
     return;
   }
 
+  // Handle registration flag
+  if (options?.register) {
+    await registerWorkerPath(process.cwd());
+    return;
+  }
+
   const toolsToUse = Tools.getToolsByNames(config.worker.allowedTools);
   mcpServer.createServer(clientName, clientVersion).withTools(toolsToUse);
 
@@ -41,13 +173,30 @@ export async function worker() {
 
     const dir = process.cwd();
     const homedir = os.homedir();
-    const root = dir === homedir ? "~" : dir.replace(homedir, "~");
+    
+    // Use environment variables if available (set by Docker), otherwise compute defaults
+    const hostname = process.env.WORKER_HOSTNAME || os.hostname();
+    const root = process.env.WORKER_ROOT || (dir === homedir ? "~" : dir.replace(homedir, "~"));
+
+    const headers: Record<string, string> = {
+      Authorization: `Bearer ${jwt}`,
+      "User-Agent": `${clientName}/${clientVersion}/${hostname}`,
+      Root: root,
+    };
+
+    // Add shared header based on flags
+    if (options?.share) {
+      headers.Shared = "true";
+      console.log("🔓 Worker shared with organization");
+    } else if (options?.unshare) {
+      headers.Shared = "false";
+      console.log("🔒 Worker is now private (unshared)");
+    } else {
+      console.log("🔒 Worker is private (only you can use it)");
+    }
+
     const ws = new WebSocket(`${API_URL}/ws/worker`, {
-      headers: {
-        Authorization: `Bearer ${jwt}`,
-        "User-Agent": `${clientName}/${clientVersion}/${os.hostname()}`,
-        Root: `${root}`,
-      },
+      headers,
     });
 
     ws.on("open", () => {

package/src/workerRegistry.ts

@@ -0,0 +1,152 @@
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { spawn, ChildProcess } from "child_process";
+
+interface WorkerRegistry {
+  workers: string[];
+}
+
+function getWorkerRegistryPath(): string {
+  return path.join(os.homedir(), ".knowhow", "workers.json");
+}
+
+export async function loadWorkerRegistry(): Promise<WorkerRegistry> {
+  const registryPath = getWorkerRegistryPath();
+  
+  try {
+    if (fs.existsSync(registryPath)) {
+      const content = await fs.promises.readFile(registryPath, "utf8");
+      return JSON.parse(content);
+    }
+  } catch (error) {
+    console.warn("Failed to load worker registry:", error);
+  }
+  
+  return { workers: [] };
+}
+
+export async function saveWorkerRegistry(registry: WorkerRegistry): Promise<void> {
+  const registryPath = getWorkerRegistryPath();
+  const dir = path.dirname(registryPath);
+  
+  // Ensure the directory exists
+  if (!fs.existsSync(dir)) {
+    await fs.promises.mkdir(dir, { recursive: true });
+  }
+  
+  await fs.promises.writeFile(
+    registryPath,
+    JSON.stringify(registry, null, 2),
+    "utf8"
+  );
+}
+
+export async function registerWorkerPath(workerPath: string): Promise<void> {
+  const registry = await loadWorkerRegistry();
+  const normalizedPath = path.resolve(workerPath);
+  
+  if (!registry.workers.includes(normalizedPath)) {
+    registry.workers.push(normalizedPath);
+    await saveWorkerRegistry(registry);
+    console.log(`✓ Registered worker path: ${normalizedPath}`);
+  } else {
+    console.log(`Worker path already registered: ${normalizedPath}`);
+  }
+}
+
+export async function unregisterWorkerPath(workerPath: string): Promise<void> {
+  const registry = await loadWorkerRegistry();
+  const normalizedPath = path.resolve(workerPath);
+  
+  const index = registry.workers.indexOf(normalizedPath);
+  if (index !== -1) {
+    registry.workers.splice(index, 1);
+    await saveWorkerRegistry(registry);
+    console.log(`✓ Unregistered worker path: ${normalizedPath}`);
+  } else {
+    console.log(`Worker path not found in registry: ${normalizedPath}`);
+  }
+}
+
+export async function listWorkerPaths(): Promise<string[]> {
+  const registry = await loadWorkerRegistry();
+  return registry.workers;
+}
+
+export async function clearWorkerRegistry(): Promise<void> {
+  await saveWorkerRegistry({ workers: [] });
+  console.log("✓ Cleared all registered worker paths");
+}
+
+interface WorkerProcess {
+  path: string;
+  process: ChildProcess;
+}
+
+export async function startAllWorkers(): Promise<void> {
+  const workerPaths = await listWorkerPaths();
+  
+  if (workerPaths.length === 0) {
+    console.log("No workers registered. Use 'knowhow worker --register' to register workers.");
+    return;
+  }
+  
+  console.log(`Starting ${workerPaths.length} worker(s)...`);
+  
+  const processes: WorkerProcess[] = [];
+  
+  for (const workerPath of workerPaths) {
+    if (!fs.existsSync(workerPath)) {
+      console.warn(`⚠ Worker path does not exist: ${workerPath}`);
+      continue;
+    }
+    
+    console.log(`Starting worker at: ${workerPath}`);
+    
+    const workerProcess = spawn("knowhow", ["worker"], {
+      cwd: workerPath,
+      stdio: "inherit",
+      detached: false,
+    });
+    
+    workerProcess.on("error", (error) => {
+      console.error(`Error in worker at ${workerPath}:`, error);
+    });
+    
+    workerProcess.on("exit", (code, signal) => {
+      console.log(`Worker at ${workerPath} exited with code ${code} and signal ${signal}`);
+    });
+    
+    processes.push({ path: workerPath, process: workerProcess });
+  }
+  
+  console.log(`\n✓ Started ${processes.length} worker(s)`);
+  console.log("Press Ctrl+C to stop all workers\n");
+  
+  // Handle graceful shutdown
+  const shutdownHandler = () => {
+    console.log("\nShutting down all workers...");
+    
+    for (const { path: workerPath, process: proc } of processes) {
+      console.log(`Stopping worker at: ${workerPath}`);
+      proc.kill("SIGTERM");
+    }
+    
+    // Give processes time to shut down gracefully
+    setTimeout(() => {
+      for (const { process: proc } of processes) {
+        if (!proc.killed) {
+          proc.kill("SIGKILL");
+        }
+      }
+      process.exit(0);
+    }, 5000);
+  };
+  
+  process.on("SIGINT", shutdownHandler);
+  process.on("SIGTERM", shutdownHandler);
+  
+  // Keep the process alive
+  await new Promise(() => {});
+}