@opentrust/cli 7.1.0 → 7.2.0

package/README.md

@@ -1,6 +1,6 @@
 # @opentrust/cli
 
-CLI tool to manage [OpenTrust](https://github.com/opentrust-dev/opentrust) — an open-source AI Agent Runtime Security Platform.
+CLI tool to manage [OpenTrust](https://github.com/opentrust/opentrust) — an open-source AI Agent Runtime Security Platform.
 
 ## Install
 

package/dist/commands/init.js

@@ -1,20 +1,51 @@
 import { execSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
-const DEFAULT_REPO = "https://github.com/anthropics/opentrust.git";
+const SCAFFOLD_PKG = {
+    name: "opentrust-project",
+    version: "1.0.0",
+    private: true,
+    description: "OpenTrust local deployment",
+    scripts: {
+        setup: "opentrust setup",
+        start: "opentrust start",
+        stop: "opentrust stop",
+        status: "opentrust status",
+    },
+    dependencies: {
+        "@opentrust/core": "^7.2.0",
+        "@opentrust/gateway": "^7.2.0",
+        "@opentrust/dashboard": "^7.2.0",
+    },
+};
+const ENV_TEMPLATE = `# OpenTrust Configuration
+
+# Dashboard
+DEV_MODE=true
+DASHBOARD_MODE=embedded
+DASHBOARD_DATA_DIR=./data
+
+# Core
+CORE_PORT=53666
+
+# Gateway
+GATEWAY_PORT=8900
+# ANTHROPIC_API_KEY=sk-ant-xxx
+# OPENAI_API_KEY=sk-xxx
+# GEMINI_API_KEY=xxx
+`;
 export function registerInitCommand(program) {
     program
         .command("init")
-        .description("Initialize OpenTrust project (clone repository into current directory)")
-        .option("--repo <url>", "Git repository URL", DEFAULT_REPO)
-        .option("--branch <name>", "Git branch to clone", "main")
+        .description("Initialize an OpenTrust project (install packages via npm)")
+        .option("--registry <url>", "npm registry URL")
         .action(async (options) => {
         const cwd = process.cwd();
         const pkgPath = path.join(cwd, "package.json");
         if (fs.existsSync(pkgPath)) {
             try {
                 const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
-                if (pkg.name === "opentrust") {
+                if (pkg.name === "opentrust" || pkg.name === "opentrust-project") {
                     console.log("OpenTrust project already exists in current directory.");
                     console.log("Run 'opentrust setup' to install dependencies.");
                     return;
@@ -22,54 +53,42 @@ export function registerInitCommand(program) {
             }
             catch { }
         }
-        try {
-            execSync("git --version", { stdio: "ignore" });
-        }
-        catch {
-            console.error("Error: git is not installed. Please install git first.");
-            process.exit(1);
+        console.log("Initializing OpenTrust project...\n");
+        // Write package.json
+        fs.writeFileSync(pkgPath, JSON.stringify(SCAFFOLD_PKG, null, 2) + "\n", "utf-8");
+        console.log("  Created package.json");
+        // Write .env
+        const envPath = path.join(cwd, ".env");
+        if (!fs.existsSync(envPath)) {
+            fs.writeFileSync(envPath, ENV_TEMPLATE, "utf-8");
+            console.log("  Created .env");
         }
-        const isEmpty = fs.readdirSync(cwd).filter(f => !f.startsWith(".")).length === 0;
-        const targetDir = isEmpty ? cwd : path.join(cwd, "opentrust");
-        if (!isEmpty && fs.existsSync(targetDir)) {
-            console.error(`Directory already exists: ${targetDir}`);
-            console.error("Remove it or choose a different location.");
-            process.exit(1);
+        // Create data directory
+        const dataDir = path.join(cwd, "data");
+        if (!fs.existsSync(dataDir)) {
+            fs.mkdirSync(dataDir, { recursive: true });
+            console.log("  Created data/");
         }
-        console.log("Initializing OpenTrust project...\n");
-        console.log(`  Repository: ${options.repo}`);
-        console.log(`  Branch:     ${options.branch}`);
-        console.log(`  Target:     ${targetDir}\n`);
+        // Install dependencies
+        console.log("\nInstalling packages...\n");
+        const registryArg = options.registry ? ` --registry ${options.registry}` : "";
         try {
-            if (isEmpty) {
-                execSync(`git clone --depth 1 --branch ${options.branch} ${options.repo} .`, { cwd, stdio: "inherit" });
-            }
-            else {
-                execSync(`git clone --depth 1 --branch ${options.branch} ${options.repo} opentrust`, { cwd, stdio: "inherit" });
-            }
+            execSync(`npm install${registryArg}`, { cwd, stdio: "inherit" });
         }
         catch {
-            console.error("\nFailed to clone repository.");
+            console.error("\nnpm install failed. Check the output above for details.");
             process.exit(1);
         }
         console.log("\n-------------------------------------------");
         console.log("OpenTrust project initialized!");
         console.log("-------------------------------------------\n");
-        if (isEmpty) {
-            console.log("Next steps:");
-            console.log("  opentrust setup          # Install dependencies (local mode)");
-            console.log("  opentrust start          # Start all services\n");
-            console.log("Or use Docker:");
-            console.log("  opentrust start --docker # Start via Docker Compose");
-        }
-        else {
-            console.log("Next steps:");
-            console.log("  cd opentrust");
-            console.log("  opentrust setup          # Install dependencies (local mode)");
-            console.log("  opentrust start          # Start all services\n");
-            console.log("Or use Docker:");
-            console.log("  cd opentrust");
-            console.log("  opentrust start --docker # Start via Docker Compose");
-        }
+        console.log("Next steps:");
+        console.log("  opentrust setup    # Run database migrations");
+        console.log("  opentrust start    # Start all services");
+        console.log("  opentrust status   # Check service health\n");
+        console.log("Services:");
+        console.log("  Core       http://localhost:53666");
+        console.log("  Dashboard  http://localhost:53667/dashboard/");
+        console.log("  Gateway    http://localhost:8900");
     });
 }

package/dist/commands/setup.js

@@ -1,6 +1,7 @@
 import { execSync } from "node:child_process";
 import fs from "node:fs";
-import { paths, requireProject } from "../lib/paths.js";
+import path from "node:path";
+import { paths, requireProject, projectMode, projectRoot } from "../lib/paths.js";
 import { dockerSetup } from "../lib/docker-manager.js";
 export function registerSetupCommand(program) {
     program
@@ -14,52 +15,123 @@ export function registerSetupCommand(program) {
             return;
         }
         requireProject();
-        console.log("OpenTrust Setup\n");
-        const steps = [
-            {
-                label: "Core",
-                cwd: paths.core,
-                commands: ["npm install"],
-            },
-            {
-                label: "Dashboard",
-                cwd: paths.dashboard,
-                commands: [
-                    "pnpm install",
-                    "pnpm build",
-                    "pnpm db:generate",
-                    "pnpm db:migrate",
-                    "pnpm db:seed",
-                ],
-            },
-            {
-                label: "Gateway",
-                cwd: paths.gateway,
-                commands: ["npm install"],
-            },
-        ];
-        for (const step of steps) {
-            if (!fs.existsSync(step.cwd)) {
-                console.log(`  ⚠ ${step.label}: directory not found, skipping`);
-                continue;
+        if (projectMode === "npm") {
+            runNpmSetup();
+        }
+        else {
+            runMonorepoSetup();
+        }
+    });
+}
+function runMonorepoSetup() {
+    console.log("OpenTrust Setup (monorepo)\n");
+    const steps = [
+        {
+            label: "Core",
+            cwd: paths.core,
+            commands: ["npm install"],
+        },
+        {
+            label: "Dashboard",
+            cwd: paths.dashboard,
+            commands: [
+                "pnpm install",
+                "pnpm build",
+                "pnpm db:generate",
+                "pnpm db:migrate",
+                "pnpm db:seed",
+            ],
+        },
+        {
+            label: "Gateway",
+            cwd: paths.gateway,
+            commands: ["npm install"],
+        },
+    ];
+    for (const step of steps) {
+        if (!fs.existsSync(step.cwd)) {
+            console.log(`  ⚠ ${step.label}: directory not found, skipping`);
+            continue;
+        }
+        console.log(`Setting up ${step.label}...`);
+        for (const cmd of step.commands) {
+            try {
+                console.log(`  $ ${cmd}`);
+                execSync(cmd, { cwd: step.cwd, stdio: "inherit" });
             }
-            console.log(`Setting up ${step.label}...`);
-            for (const cmd of step.commands) {
-                try {
-                    console.log(`  $ ${cmd}`);
-                    execSync(cmd, { cwd: step.cwd, stdio: "inherit" });
-                }
-                catch (err) {
-                    console.error(`  Failed: ${cmd}`);
-                    process.exit(1);
-                }
+            catch (err) {
+                console.error(`  Failed: ${cmd}`);
+                process.exit(1);
             }
-            console.log(`  ${step.label} ready.\n`);
         }
-        console.log("-------------------------------------------");
-        console.log("Setup complete!");
-        console.log("-------------------------------------------");
-        console.log("\nRun 'opentrust start' to launch all services.");
-        console.log("Or start individually: 'opentrust start core'");
-    });
+        console.log(`  ${step.label} ready.\n`);
+    }
+    printSetupDone();
+}
+function runNpmSetup() {
+    console.log("OpenTrust Setup (npm packages)\n");
+    const dataDir = path.join(projectRoot, "data");
+    if (!fs.existsSync(dataDir)) {
+        fs.mkdirSync(dataDir, { recursive: true });
+    }
+    const env = {
+        ...process.env,
+        DASHBOARD_DATA_DIR: dataDir,
+        DEV_MODE: "true",
+    };
+    // Load .env from project root if exists
+    const envFile = path.join(projectRoot, ".env");
+    if (fs.existsSync(envFile)) {
+        const content = fs.readFileSync(envFile, "utf-8");
+        for (const line of content.split("\n")) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith("#"))
+                continue;
+            const eqIdx = trimmed.indexOf("=");
+            if (eqIdx > 0) {
+                const key = trimmed.slice(0, eqIdx).trim();
+                const val = trimmed.slice(eqIdx + 1).trim();
+                if (!env[key])
+                    env[key] = val;
+            }
+        }
+    }
+    // Run db:migrate
+    const migrateScript = path.join(projectRoot, "node_modules", "@opentrust", "db", "dist", "migrate.js");
+    if (fs.existsSync(migrateScript)) {
+        console.log("Running database migrations...");
+        try {
+            execSync(`node ${migrateScript}`, { cwd: projectRoot, stdio: "inherit", env });
+        }
+        catch {
+            console.error("  Migration failed.");
+            process.exit(1);
+        }
+        console.log("  Migrations complete.\n");
+    }
+    else {
+        console.log("  ⚠ @opentrust/db not found, skipping migrations.");
+        console.log("  Run 'npm install' first.\n");
+    }
+    // Run db:seed
+    const seedScript = path.join(projectRoot, "node_modules", "@opentrust", "db", "dist", "seed.js");
+    if (fs.existsSync(seedScript)) {
+        console.log("Seeding database...");
+        try {
+            execSync(`node ${seedScript}`, { cwd: projectRoot, stdio: "inherit", env });
+        }
+        catch {
+            console.error("  Seed failed.");
+            process.exit(1);
+        }
+        console.log("  Seed complete.\n");
+    }
+    printSetupDone();
+}
+function printSetupDone() {
+    console.log("-------------------------------------------");
+    console.log("Setup complete!");
+    console.log("-------------------------------------------");
+    console.log("\nRun 'opentrust start' to launch all services.");
+    console.log("Or start individually: 'opentrust start core'");
 }

package/dist/lib/paths.d.ts

@@ -1,6 +1,13 @@
+export type ProjectMode = "monorepo" | "npm" | "none";
+export declare const projectMode: ProjectMode;
+export declare const projectRoot: string;
 export declare function isProjectAvailable(): boolean;
 export declare function requireProject(): void;
 export declare function hasDockerCompose(): boolean;
+/** Resolve a node_modules package entry point */
+export declare function resolveNpmPackage(packageName: string): string | null;
+/** Resolve a bin script from a node_modules package */
+export declare function resolveNpmBin(packageName: string, binName: string): string | null;
 export declare const paths: {
     projectRoot: string;
     runtime: string;

package/dist/lib/paths.js

@@ -3,35 +3,41 @@ import os from "node:os";
 import fs from "node:fs";
 import { fileURLToPath } from "node:url";
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
-function findProjectRoot() {
+function detectProjectMode() {
     // 1. OPENTRUST_HOME env var takes priority
     if (process.env.OPENTRUST_HOME) {
-        return path.resolve(process.env.OPENTRUST_HOME);
+        const dir = path.resolve(process.env.OPENTRUST_HOME);
+        if (isMonorepoRoot(dir))
+            return { mode: "monorepo", root: dir };
+        if (isNpmProject(dir))
+            return { mode: "npm", root: dir };
+        return { mode: "none", root: dir };
     }
-    // 2. Check if cwd looks like the opentrust project root
     const cwd = process.cwd();
-    if (isOpenTrustRoot(cwd)) {
-        return cwd;
-    }
-    // 3. Walk up from cwd looking for the project root
+    // 2. Check cwd
+    if (isMonorepoRoot(cwd))
+        return { mode: "monorepo", root: cwd };
+    if (isNpmProject(cwd))
+        return { mode: "npm", root: cwd };
+    // 3. Walk up from cwd
     let dir = cwd;
     while (true) {
         const parent = path.dirname(dir);
         if (parent === dir)
             break;
         dir = parent;
-        if (isOpenTrustRoot(dir))
-            return dir;
+        if (isMonorepoRoot(dir))
+            return { mode: "monorepo", root: dir };
+        if (isNpmProject(dir))
+            return { mode: "npm", root: dir };
     }
-    // 4. Fallback: resolve relative to __dirname (works inside monorepo)
+    // 4. Fallback: resolve relative to __dirname (within monorepo)
     const fallback = path.resolve(__dirname, "../../..");
-    if (isOpenTrustRoot(fallback)) {
-        return fallback;
-    }
-    // 5. Last resort: use cwd and let commands fail with meaningful errors
-    return cwd;
+    if (isMonorepoRoot(fallback))
+        return { mode: "monorepo", root: fallback };
+    return { mode: "none", root: cwd };
 }
-function isOpenTrustRoot(dir) {
+function isMonorepoRoot(dir) {
     try {
         const pkgPath = path.join(dir, "package.json");
         if (!fs.existsSync(pkgPath))
@@ -43,9 +49,26 @@ function isOpenTrustRoot(dir) {
         return false;
     }
 }
-const projectRoot = findProjectRoot();
+function isNpmProject(dir) {
+    try {
+        const pkgPath = path.join(dir, "package.json");
+        if (!fs.existsSync(pkgPath))
+            return false;
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+        if (pkg.name === "opentrust-project")
+            return true;
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        return !!deps["@opentrust/core"] || !!deps["@opentrust/dashboard"];
+    }
+    catch {
+        return false;
+    }
+}
+const detected = detectProjectMode();
+export const projectMode = detected.mode;
+export const projectRoot = detected.root;
 export function isProjectAvailable() {
-    return isOpenTrustRoot(projectRoot);
+    return detected.mode !== "none";
 }
 export function requireProject() {
     if (!isProjectAvailable()) {
@@ -62,6 +85,21 @@ export function requireProject() {
 export function hasDockerCompose() {
     return fs.existsSync(path.join(projectRoot, "docker-compose.yml"));
 }
+/** Resolve a node_modules package entry point */
+export function resolveNpmPackage(packageName) {
+    const entryPoints = [
+        path.join(projectRoot, "node_modules", packageName, "dist", "index.js"),
+        path.join(projectRoot, "node_modules", packageName, "index.js"),
+    ];
+    return entryPoints.find(p => fs.existsSync(p)) ?? null;
+}
+/** Resolve a bin script from a node_modules package */
+export function resolveNpmBin(packageName, binName) {
+    const binPath = path.join(projectRoot, "node_modules", ".bin", binName);
+    if (fs.existsSync(binPath))
+        return binPath;
+    return null;
+}
 /** ~/.opentrust/ — runtime data (pid files, logs) */
 const runtimeDir = path.join(os.homedir(), ".opentrust");
 export const paths = {

package/dist/lib/process-manager.d.ts

@@ -7,6 +7,7 @@ export interface ServiceDef {
     logFile: string;
     port: number;
     healthUrl?: string;
+    env?: Record<string, string>;
 }
 export declare const SERVICES: Record<string, ServiceDef>;
 export declare function startService(key: string): boolean;

package/dist/lib/process-manager.js

@@ -1,38 +1,91 @@
 import { spawn } from "node:child_process";
 import fs from "node:fs";
-import { paths } from "./paths.js";
-export const SERVICES = {
-    core: {
-        name: "Core",
-        cwd: paths.core,
-        command: "npx",
-        args: ["tsx", "src/index.ts"],
-        pidFile: paths.corePid,
-        logFile: paths.coreLog,
-        port: 53666,
-        healthUrl: "http://localhost:53666/health",
-    },
-    dashboard: {
-        name: "Dashboard",
-        cwd: paths.dashboard,
-        command: "npx",
-        args: ["turbo", "dev"],
-        pidFile: paths.dashboardPid,
-        logFile: paths.dashboardLog,
-        port: 53667,
-        healthUrl: "http://localhost:53667/health",
-    },
-    gateway: {
-        name: "Gateway",
-        cwd: paths.gateway,
-        command: "npx",
-        args: ["tsx", "src/index.ts"],
-        pidFile: paths.gatewayPid,
-        logFile: paths.gatewayLog,
-        port: 8900,
-        healthUrl: "http://localhost:8900/health",
-    },
-};
+import path from "node:path";
+import { paths, projectMode, projectRoot, resolveNpmPackage } from "./paths.js";
+function buildServices() {
+    if (projectMode === "npm") {
+        return buildNpmServices();
+    }
+    return buildMonorepoServices();
+}
+function buildMonorepoServices() {
+    return {
+        core: {
+            name: "Core",
+            cwd: paths.core,
+            command: "npx",
+            args: ["tsx", "src/index.ts"],
+            pidFile: paths.corePid,
+            logFile: paths.coreLog,
+            port: 53666,
+            healthUrl: "http://localhost:53666/health",
+        },
+        dashboard: {
+            name: "Dashboard",
+            cwd: paths.dashboard,
+            command: "npx",
+            args: ["turbo", "dev"],
+            pidFile: paths.dashboardPid,
+            logFile: paths.dashboardLog,
+            port: 53667,
+            healthUrl: "http://localhost:53667/health",
+        },
+        gateway: {
+            name: "Gateway",
+            cwd: paths.gateway,
+            command: "npx",
+            args: ["tsx", "src/index.ts"],
+            pidFile: paths.gatewayPid,
+            logFile: paths.gatewayLog,
+            port: 8900,
+            healthUrl: "http://localhost:8900/health",
+        },
+    };
+}
+function buildNpmServices() {
+    const coreEntry = resolveNpmPackage("@opentrust/core");
+    const dashboardEntry = resolveNpmPackage("@opentrust/dashboard");
+    const gatewayEntry = resolveNpmPackage("@opentrust/gateway");
+    const dataDir = path.join(projectRoot, "data");
+    return {
+        core: {
+            name: "Core",
+            cwd: projectRoot,
+            command: "node",
+            args: [coreEntry || "node_modules/@opentrust/core/dist/index.js"],
+            pidFile: paths.corePid,
+            logFile: paths.coreLog,
+            port: 53666,
+            healthUrl: "http://localhost:53666/health",
+        },
+        dashboard: {
+            name: "Dashboard",
+            cwd: projectRoot,
+            command: "node",
+            args: [dashboardEntry || "node_modules/@opentrust/dashboard/dist/index.js"],
+            pidFile: paths.dashboardPid,
+            logFile: paths.dashboardLog,
+            port: 53667,
+            healthUrl: "http://localhost:53667/health",
+            env: {
+                DASHBOARD_MODE: "embedded",
+                DEV_MODE: "true",
+                DASHBOARD_DATA_DIR: dataDir,
+            },
+        },
+        gateway: {
+            name: "Gateway",
+            cwd: projectRoot,
+            command: "node",
+            args: [gatewayEntry || "node_modules/@opentrust/gateway/dist/index.js"],
+            pidFile: paths.gatewayPid,
+            logFile: paths.gatewayLog,
+            port: 8900,
+            healthUrl: "http://localhost:8900/health",
+        },
+    };
+}
+export const SERVICES = buildServices();
 function ensureDirs() {
     for (const dir of [paths.runtime, paths.logs]) {
         if (!fs.existsSync(dir))
@@ -45,7 +98,7 @@ export function startService(key) {
         console.error(`Unknown service: ${key}`);
         return false;
     }
-    if (!fs.existsSync(svc.cwd)) {
+    if (projectMode === "monorepo" && !fs.existsSync(svc.cwd)) {
         console.error(`  ${svc.name}: directory not found at ${svc.cwd}`);
         return false;
     }
@@ -58,7 +111,7 @@ export function startService(key) {
     const logFd = fs.openSync(svc.logFile, "a");
     const child = spawn(svc.command, svc.args, {
         cwd: svc.cwd,
-        env: { ...process.env, FORCE_COLOR: "0" },
+        env: { ...process.env, FORCE_COLOR: "0", ...svc.env },
         stdio: ["ignore", logFd, logFd],
         detached: true,
     });
@@ -85,7 +138,6 @@ export function stopService(key) {
         return false;
     }
     try {
-        // Kill the process group (negative PID) to stop all children
         process.kill(-status.pid, "SIGTERM");
     }
     catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opentrust/cli",
-  "version": "7.1.0",
+  "version": "7.2.0",
   "description": "CLI tool to manage OpenTrust AI Agent Runtime Security Platform — setup, start, stop, status, logs",
   "type": "module",
   "bin": {
@@ -33,14 +33,14 @@
     "llm-security",
     "ai-agent"
   ],
-  "homepage": "https://github.com/opentrust-dev/opentrust#readme",
+  "homepage": "https://github.com/opentrust/opentrust#readme",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/opentrust-dev/opentrust.git",
+    "url": "git+https://github.com/opentrust/opentrust.git",
     "directory": "cli"
   },
   "bugs": {
-    "url": "https://github.com/opentrust-dev/opentrust/issues"
+    "url": "https://github.com/opentrust/opentrust/issues"
   },
   "author": "OpenTrust",
   "license": "Apache-2.0",