@_xtribe/cli 1.0.0-beta.19 → 1.0.0-beta.22

package/install-tribe.js

@@ -93,6 +93,60 @@ async function downloadFile(url, dest) {
 
 // Docker installation removed - Colima provides Docker runtime
 
+async function installK3s() {
+    if (platform !== 'linux') {
+        return true; // K3s is Linux only
+    }
+    
+    const spinner = ora('Installing K3s (lightweight Kubernetes)...').start();
+    
+    try {
+        // Check if already installed
+        try {
+            execSync('k3s --version', { stdio: 'ignore' });
+            spinner.succeed('K3s already installed');
+            return true;
+        } catch {
+            // Not installed, continue
+        }
+        
+        // One-line K3s installation
+        spinner.text = 'Installing K3s (this may take a few minutes)...';
+        console.log(chalk.yellow('\n📦 Installing K3s - Lightweight Kubernetes'));
+        console.log(chalk.gray('This is a one-line installation that will:'));
+        console.log(chalk.gray('  • Download and install K3s'));
+        console.log(chalk.gray('  • Configure systemd service'));
+        console.log(chalk.gray('  • Set up kubectl access'));
+        console.log(chalk.gray('  • Disable Traefik (we use our own ingress)\n'));
+        
+        execSync('curl -sfL https://get.k3s.io | sh -s - --disable traefik --write-kubeconfig-mode 644', {
+            stdio: 'inherit',
+            shell: '/bin/bash'
+        });
+        
+        // Wait for K3s to be ready
+        spinner.text = 'Waiting for K3s to be ready...';
+        await new Promise(resolve => setTimeout(resolve, 10000));
+        
+        // Make kubectl available
+        try {
+            execSync('sudo ln -sf /usr/local/bin/k3s /usr/local/bin/kubectl', { stdio: 'ignore' });
+        } catch {
+            // Link might already exist
+        }
+        
+        // Set KUBECONFIG for current process
+        process.env.KUBECONFIG = '/etc/rancher/k3s/k3s.yaml';
+        
+        spinner.succeed('K3s installed successfully');
+        return true;
+    } catch (error) {
+        spinner.fail(`K3s installation failed: ${error.message}`);
+        log.info('You can install K3s manually with: curl -sfL https://get.k3s.io | sh -');
+        return false;
+    }
+}
+
 async function installColima() {
     if (platform !== 'darwin') {
         log.info('Colima is only needed on macOS - skipping');
@@ -149,6 +203,23 @@ async function installColima() {
 // KIND installation removed - using Colima's built-in Kubernetes
 
 async function installKubectl() {
+    // Linux with K3s already has kubectl
+    if (platform === 'linux') {
+        try {
+            execSync('k3s kubectl version --client', { stdio: 'ignore' });
+            log.success('kubectl available via k3s');
+            // Create a symlink for convenience
+            try {
+                execSync('sudo ln -sf /usr/local/bin/k3s /usr/local/bin/kubectl', { stdio: 'ignore' });
+            } catch {
+                // Link might already exist
+            }
+            return true;
+        } catch {
+            // Continue with regular kubectl installation
+        }
+    }
+    
     if (await checkCommand('kubectl')) {
         log.success('kubectl already installed');
         return true;
@@ -174,65 +245,63 @@ async function installKubectl() {
     }
 }
 
-async function installTribeCli() {
+async function installTribeCLI() {
     const spinner = ora('Installing TRIBE CLI...').start();
     
     try {
         const tribeDest = path.join(binDir, 'tribe');
         
-        // First check if we have a bundled binary
-        const bundledBinary = path.join(__dirname, 'tribe');
-        if (fs.existsSync(bundledBinary)) {
-            fs.copyFileSync(bundledBinary, tribeDest);
-            fs.chmodSync(tribeDest, '755');
-            spinner.succeed('TRIBE CLI installed from bundled binary');
-            return true;
-        }
-        
-        // Check if we have local source
-        const sourceFile = path.join(__dirname, 'cluster-cli.go');
-        if (fs.existsSync(sourceFile)) {
-            // Build from source
+        // Skip if already installed and working
+        if (fs.existsSync(tribeDest)) {
             try {
-                execSync('go version', { stdio: 'ignore' });
-                execSync(`cd ${__dirname} && go build -o tribe cluster-cli.go client.go`);
-                fs.copyFileSync(path.join(__dirname, 'tribe'), tribeDest);
-                fs.chmodSync(tribeDest, '755');
-                spinner.succeed('TRIBE CLI built from source');
+                execSync(`${tribeDest} version`, { stdio: 'ignore' });
+                spinner.succeed('TRIBE CLI already installed');
                 return true;
             } catch {
-                spinner.warn('Go not available, trying pre-built binary...');
+                // Binary exists but doesn't work, remove it
+                fs.unlinkSync(tribeDest);
             }
         }
         
-        // Try pre-built binary from GitHub
-        const tribeUrl = `https://github.com/0zen/0zen/releases/latest/download/tribe-${platform}-${arch}`;
-        
-        try {
-            await downloadFile(tribeUrl, tribeDest);
-            fs.chmodSync(tribeDest, '755');
-            spinner.succeed('TRIBE CLI installed');
-            return true;
-        } catch {
-            // Fallback: look for any existing tribe binary
-            const possiblePaths = [
-                path.join(__dirname, '..', 'tribe-cli'),
-                path.join(__dirname, '..', 'tribe'),
-                './tribe-cli',
-                './tribe'
-            ];
-            
-            for (const possiblePath of possiblePaths) {
-                if (fs.existsSync(possiblePath)) {
-                    fs.copyFileSync(possiblePath, tribeDest);
-                    fs.chmodSync(tribeDest, '755');
-                    spinner.succeed('TRIBE CLI installed from local binary');
-                    return true;
-                }
+        // Download pre-built binary from GitHub
+        const arch = process.arch === 'x64' ? 'amd64' : 'arm64';
+        const platform = os.platform();
+        
+        // Multiple sources for reliability
+        const sources = [
+            // GitHub releases (primary source)
+            `https://github.com/TRIBE-INC/0zen/releases/latest/download/tribe-${platform}-${arch}`,
+            // Try jsDelivr CDN as fallback
+            `https://cdn.jsdelivr.net/gh/TRIBE-INC/0zen@latest/releases/tribe-${platform}-${arch}`,
+            // Direct raw GitHub as last resort
+            `https://raw.githubusercontent.com/TRIBE-INC/0zen/main/releases/tribe-${platform}-${arch}`
+        ];
+        
+        let downloaded = false;
+        let lastError;
+        
+        for (const url of sources) {
+            spinner.text = `Downloading TRIBE CLI from ${url.includes('jsdelivr') ? 'CDN' : 'GitHub'}...`;
+            try {
+                await downloadFile(url, tribeDest);
+                fs.chmodSync(tribeDest, '755');
+                
+                // Verify the binary works
+                execSync(`${tribeDest} version`, { stdio: 'ignore' });
+                spinner.succeed('TRIBE CLI installed successfully');
+                downloaded = true;
+                break;
+            } catch (error) {
+                lastError = error;
+                log.warning(`Failed to download from ${url.split('/').slice(2, 3).join('/')}, trying next source...`);
             }
-            
-            throw new Error('No TRIBE CLI binary available');
         }
+        
+        if (!downloaded) {
+            throw new Error(`Failed to download TRIBE CLI: ${lastError?.message || 'All sources failed'}`);
+        }
+        
+        return true;
     } catch (error) {
         spinner.fail(`TRIBE CLI installation failed: ${error.message}`);
         return false;
@@ -240,17 +309,18 @@ async function installTribeCli() {
 }
 
 async function startContainerRuntime() {
-    if (platform !== 'darwin') {
-        return true; // Linux uses Docker daemon directly
-    }
-
-    // Check if container runtime is already working
+    const spinner = ora('Starting container runtime...').start();
+    
     try {
-        execSync('docker info', { stdio: 'ignore' });
-        log.success('Container runtime is already working');
-        return true;
-    } catch {
-        // Try to start Colima with different approaches
+        // Platform-specific container runtime handling
+        if (platform === 'darwin') {
+            // macOS - Check if container runtime is already working via Colima
+            try {
+                execSync('docker info', { stdio: 'ignore' });
+                log.success('Container runtime is already working');
+                return true;
+            } catch {
+                // Try to start Colima with different approaches
         if (await checkCommand('colima')) {
             const spinner = ora('Starting Colima container runtime...').start();
             
@@ -307,8 +377,40 @@ async function startContainerRuntime() {
                 }
             }
         }
+            }
+        } else if (platform === 'linux') {
+            // Linux - K3s should already be running
+            spinner.text = 'Checking K3s status...';
+            try {
+                execSync('sudo systemctl is-active --quiet k3s', { stdio: 'ignore' });
+                spinner.succeed('K3s is running');
+                return true;
+            } catch {
+                // Try to start K3s
+                spinner.text = 'Starting K3s...';
+                try {
+                    execSync('sudo systemctl start k3s', { stdio: 'ignore' });
+                    await new Promise(resolve => setTimeout(resolve, 5000));
+                    spinner.succeed('K3s started');
+                    return true;
+                } catch (error) {
+                    spinner.fail('Failed to start K3s');
+                    log.error('Please ensure K3s is installed and you have sudo access');
+                    return false;
+                }
+            }
+        } else if (platform === 'win32') {
+            spinner.fail('Windows support coming soon!');
+            log.info('For Windows, please use WSL2 with Ubuntu and run this installer inside WSL2');
+            return false;
+        } else {
+            spinner.fail(`Unsupported platform: ${platform}`);
+            return false;
+        }
+    } catch (error) {
+        spinner.fail(`Container runtime error: ${error.message}`);
+        return false;
     }
-    return false;
 }
 
 async function updatePath() {
@@ -488,6 +590,32 @@ async function deployTribeCluster() {
         if (fs.existsSync(sourceYaml)) {
             fs.copyFileSync(sourceYaml, destYaml);
             log.info('Copied deployment configuration');
+        } else {
+            // Download deployment YAML if not bundled
+            spinner.text = 'Downloading deployment configuration...';
+            const yamlSources = [
+                // Direct from GitHub (primary)
+                'https://raw.githubusercontent.com/TRIBE-INC/0zen/main/sdk/cmd/cli-gui/package/tribe-deployment.yaml',
+                // jsDelivr CDN as fallback
+                'https://cdn.jsdelivr.net/gh/TRIBE-INC/0zen@main/sdk/cmd/cli-gui/package/tribe-deployment.yaml'
+            ];
+            
+            let yamlDownloaded = false;
+            for (const yamlUrl of yamlSources) {
+                try {
+                    await downloadFile(yamlUrl, destYaml);
+                    log.info('Downloaded deployment configuration');
+                    yamlDownloaded = true;
+                    break;
+                } catch (downloadError) {
+                    // Try next source
+                }
+            }
+            
+            if (!yamlDownloaded) {
+                spinner.fail('Failed to get deployment configuration');
+                throw new Error('Could not download deployment YAML from any source');
+            }
         }
         
         // Run tribe start command with deployment YAML path
@@ -658,17 +786,40 @@ async function promptForClusterSetup() {
 async function main() {
     console.log(chalk.bold.blue('\n🚀 TRIBE CLI Complete Installer\n'));
     
+    // Detect and display platform info
+    const arch = process.arch === 'x64' ? 'amd64' : process.arch;
+    console.log(chalk.cyan(`Platform: ${platform} (${arch})`));
+    console.log(chalk.cyan(`Node: ${process.version}`));
+    console.log('');
+    
+    // Check for unsupported platforms early
+    if (platform === 'win32') {
+        console.log(chalk.yellow('\n⚠️  Windows is not yet supported'));
+        console.log(chalk.yellow('Please use WSL2 with Ubuntu and run this installer inside WSL2'));
+        console.log(chalk.yellow('Instructions: https://docs.microsoft.com/en-us/windows/wsl/install\n'));
+        process.exit(1);
+    }
+    
     log.info(`Detected: ${platform} (${arch})`);
     log.info(`Installing to: ${binDir}`);
     
     // Update PATH first
     await updatePath();
     
-    const tasks = [
-        { name: 'Colima', fn: installColima },
+    const tasks = [];
+    
+    // Platform-specific Kubernetes installation
+    if (platform === 'darwin') {
+        tasks.push({ name: 'Colima', fn: installColima });
+    } else if (platform === 'linux') {
+        tasks.push({ name: 'K3s', fn: installK3s });
+    }
+    
+    // Common tools for all platforms
+    tasks.push(
         { name: 'kubectl', fn: installKubectl },
-        { name: 'TRIBE CLI', fn: installTribeCli }
-    ];
+        { name: 'TRIBE CLI', fn: installTribeCLI }
+    );
     
     let allSuccess = true;
     
@@ -688,7 +839,7 @@ async function main() {
         // Check if cluster already exists
         const clusterExists = await checkClusterExists();
         
-        if (!clusterExists) {
+        if (!clusterExists && !global.skipCluster) {
             // Prompt for cluster setup
             const shouldSetup = await promptForClusterSetup();
             
@@ -792,13 +943,24 @@ if (require.main === module) {
     
     if (args.includes('--help') || args.includes('-h')) {
         console.log(chalk.bold.blue('TRIBE CLI Installer\n'));
-        console.log('Usage: npx tribe-cli-local [options]\n');
+        console.log('Usage: npx @_xtribe/cli [options]\n');
         console.log('Options:');
         console.log('  --help, -h     Show this help message');
         console.log('  --verify       Only verify existing installation');
         console.log('  --dry-run      Show what would be installed');
+        console.log('  --skip-cluster Skip cluster deployment (for testing)');
                 console.log('\nThis installer sets up the complete TRIBE development environment:');
-        console.log('• Colima (Container runtime with Kubernetes)');
+        
+        if (platform === 'darwin') {
+            console.log('• Colima (Container runtime with Kubernetes)');
+        } else if (platform === 'linux') {
+            console.log('• K3s (Lightweight Kubernetes, one-line install)');
+        } else if (platform === 'win32') {
+            console.log('\n⚠️  Windows support coming soon!');
+            console.log('Please use WSL2 with Ubuntu and run this installer inside WSL2');
+            process.exit(1);
+        }
+        
         console.log('• kubectl (Kubernetes CLI)');
         console.log('• TRIBE CLI (Multi-agent orchestration)');
         console.log('\nAfter installation:');
@@ -826,6 +988,9 @@ if (require.main === module) {
         process.exit(0);
     }
     
+    // Store skip-cluster flag
+    global.skipCluster = args.includes('--skip-cluster');
+    
     main().catch(error => {
         console.error(chalk.red('Installation failed:'), error.message);
         process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@_xtribe/cli",
-  "version": "1.0.0-beta.19",
+  "version": "1.0.0-beta.22",
   "description": "TRIBE multi-agent development system - Zero to productive with one command",
   "main": "install-tribe.js",
   "bin": {
@@ -35,9 +35,6 @@
   },
   "files": [
     "install-tribe.js",
-    "lima-guestagent.Linux-aarch64.gz",
-    "tribe-deployment.yaml",
-    "tribe",
     "README.md",
     "package.json"
   ],

package/tribe-deployment.yaml

@@ -1,455 +0,0 @@
----
-# TRIBE Complete Deployment - Bundled with NPM Package
-# This file is automatically deployed by 'npx @_xtribe/cli'
-#
-# IMPORTANT: This deployment uses PUBLIC Docker Hub images from tribexal/tribe
-# - tribexal/tribe:latest-taskmaster
-# - tribexal/tribe:latest-bridge
-# - tribexal/tribe:latest-claude-agent
-#
-# DO NOT change these to local image names for the npm package!
----
-apiVersion: v1
-kind: Namespace
-metadata:
-  name: tribe-system
----
-# ServiceAccount for Bridge
-apiVersion: v1
-kind: ServiceAccount
-metadata:
-  name: bridge
-  namespace: tribe-system
----
-# Role for Bridge
-apiVersion: rbac.authorization.k8s.io/v1
-kind: Role
-metadata:
-  name: bridge-role
-  namespace: tribe-system
-rules:
-  - apiGroups: [""]
-    resources: ["pods", "services", "pods/exec", "pods/log", "configmaps", "secrets", "namespaces"]
-    verbs: ["get", "list", "watch", "create", "update", "patch", "delete"]
-  - apiGroups: ["apps"]
-    resources: ["deployments", "replicasets"]
-    verbs: ["get", "list", "watch", "create", "update", "patch", "delete"]
-  - apiGroups: ["batch"]
-    resources: ["jobs"]
-    verbs: ["get", "list", "watch", "create", "update", "patch", "delete"]
----
-# RoleBinding for Bridge
-apiVersion: rbac.authorization.k8s.io/v1
-kind: RoleBinding
-metadata:
-  name: bridge-rolebinding
-  namespace: tribe-system
-subjects:
-  - kind: ServiceAccount
-    name: bridge
-    namespace: tribe-system
-roleRef:
-  kind: Role
-  name: bridge-role
-  apiGroup: rbac.authorization.k8s.io
----
-# PostgreSQL
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: postgres
-  namespace: tribe-system
-spec:
-  replicas: 1
-  selector:
-    matchLabels:
-      app: postgres
-  template:
-    metadata:
-      labels:
-        app: postgres
-    spec:
-      containers:
-      - name: postgres
-        image: postgres:15
-        env:
-        - name: POSTGRES_DB
-          value: gitea
-        - name: POSTGRES_USER
-          value: gitea
-        - name: POSTGRES_PASSWORD
-          value: gitea
-        ports:
-        - containerPort: 5432
-        readinessProbe:
-          exec:
-            command:
-            - pg_isready
-            - -U
-            - gitea
-          initialDelaySeconds: 5
-          periodSeconds: 5
----
-apiVersion: v1
-kind: Service
-metadata:
-  name: postgres
-  namespace: tribe-system
-spec:
-  selector:
-    app: postgres
-  ports:
-  - port: 5432
----
-# Gitea
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: gitea
-  namespace: tribe-system
-spec:
-  replicas: 1
-  selector:
-    matchLabels:
-      app: gitea
-  template:
-    metadata:
-      labels:
-        app: gitea
-    spec:
-      initContainers:
-      - name: wait-for-db
-        image: busybox:1.35
-        command: ['sh', '-c', 'until nc -z postgres 5432; do echo waiting for db; sleep 2; done']
-      - name: init-gitea
-        image: gitea/gitea:1.20.5
-        command: ['/bin/bash', '-c']
-        args:
-        - |
-          # Create app.ini
-          mkdir -p /data/gitea/conf
-          cat > /data/gitea/conf/app.ini << 'EOF'
-          APP_NAME = Gitea
-          RUN_MODE = prod
-          
-          [database]
-          DB_TYPE = postgres
-          HOST = postgres:5432
-          NAME = gitea
-          USER = gitea
-          PASSWD = gitea
-          
-          [server]
-          DOMAIN = gitea
-          ROOT_URL = http://gitea:3000/
-          HTTP_PORT = 3000
-          
-          [service]
-          DISABLE_REGISTRATION = true
-          
-          [security]
-          INSTALL_LOCK = true
-          SECRET_KEY = changeme
-          EOF
-          
-          # Run migrations
-          gitea migrate
-          
-          # Create admin user
-          gitea admin user create --admin --username gitea_admin --password admin123 --email admin@example.com || true
-        env:
-        - name: GITEA_WORK_DIR
-          value: /data
-        - name: GITEA_CUSTOM
-          value: /data/gitea
-        volumeMounts:
-        - name: gitea-data
-          mountPath: /data
-      containers:
-      - name: gitea
-        image: gitea/gitea:1.20.5
-        ports:
-        - containerPort: 3000
-        env:
-        - name: GITEA_WORK_DIR
-          value: /data
-        - name: GITEA_CUSTOM
-          value: /data/gitea
-        volumeMounts:
-        - name: gitea-data
-          mountPath: /data
-        readinessProbe:
-          httpGet:
-            path: /
-            port: 3000
-          initialDelaySeconds: 30
-          periodSeconds: 10
-      volumes:
-      - name: gitea-data
-        emptyDir: {}
----
-apiVersion: v1
-kind: Service
-metadata:
-  name: gitea
-  namespace: tribe-system
-spec:
-  selector:
-    app: gitea
-  ports:
-  - port: 3000
----
-# TaskMaster
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: taskmaster
-  namespace: tribe-system
-spec:
-  replicas: 1
-  selector:
-    matchLabels:
-      app: taskmaster
-  template:
-    metadata:
-      labels:
-        app: taskmaster
-    spec:
-      initContainers:
-      - name: wait-for-db
-        image: busybox:1.35
-        command: ['sh', '-c', 'until nc -z postgres 5432; do echo waiting for db; sleep 2; done']
-      containers:
-      - name: taskmaster
-        image: tribexal/tribe:latest-taskmaster
-        imagePullPolicy: IfNotPresent
-        ports:
-        - containerPort: 5000
-        env:
-        - name: FLASK_ENV
-          value: development
-        - name: DATABASE_URL
-          value: postgresql://gitea:gitea@postgres:5432/gitea
-        - name: GITEA_URL
-          value: http://gitea:3000
-        - name: GITEA_TOKEN
-          value: will-be-set-by-init-job
-        readinessProbe:
-          httpGet:
-            path: /
-            port: 5000
-          initialDelaySeconds: 10
-          periodSeconds: 5
----
-apiVersion: v1
-kind: Service
-metadata:
-  name: taskmaster
-  namespace: tribe-system
-spec:
-  selector:
-    app: taskmaster
-  ports:
-  - port: 5000
----
-# Bridge
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: bridge
-  namespace: tribe-system
-spec:
-  replicas: 1
-  selector:
-    matchLabels:
-      app: bridge
-  template:
-    metadata:
-      labels:
-        app: bridge
-    spec:
-      serviceAccountName: bridge
-      initContainers:
-      - name: wait-for-services
-        image: busybox:1.35
-        command: ['sh', '-c']
-        args:
-        - |
-          echo "Waiting for services..."
-          until nc -z taskmaster 5000; do echo waiting for taskmaster; sleep 2; done
-          until nc -z gitea 3000; do echo waiting for gitea; sleep 2; done
-          echo "All services ready!"
-      containers:
-      - name: bridge
-        image: tribexal/tribe:latest-bridge
-        imagePullPolicy: IfNotPresent
-        ports:
-        - containerPort: 8080
-        - containerPort: 3456
-        env:
-        - name: TASKMASTER_URL
-          value: http://taskmaster:5000
-        - name: GITEA_URL
-          value: http://gitea:3000
-        - name: GITEA_ADMIN_USER
-          value: gitea_admin
-        - name: GITEA_ADMIN_PASSWORD
-          value: admin123
-        - name: NAMESPACE
-          value: tribe-system
-        readinessProbe:
-          httpGet:
-            path: /health
-            port: 8080
-          initialDelaySeconds: 10
-          periodSeconds: 5
----
-apiVersion: v1
-kind: Service
-metadata:
-  name: bridge
-  namespace: tribe-system
-spec:
-  selector:
-    app: bridge
-  ports:
-  - name: http
-    port: 8080
-  - name: websocket
-    port: 3456
----
-# Claude Worker Deployment (starts with 0 replicas)
-apiVersion: apps/v1
-kind: Deployment
-metadata:
-  name: claude-worker-deployment
-  namespace: tribe-system
-spec:
-  replicas: 0
-  selector:
-    matchLabels:
-      app: claude-worker
-  template:
-    metadata:
-      labels:
-        app: claude-worker
-    spec:
-      containers:
-      - name: claude-agent
-        image: tribexal/tribe:latest-claude-agent
-        imagePullPolicy: IfNotPresent
-        env:
-        - name: ROLE
-          value: worker
-        - name: TASKMASTER_URL
-          value: http://taskmaster:5000
-        - name: GITEA_URL
-          value: http://gitea:3000
-        - name: NAMESPACE
-          value: tribe-system
-        - name: ANTHROPIC_API_KEY
-          valueFrom:
-            secretKeyRef:
-              name: claude-api-key
-              key: api-key
-              optional: true
-        volumeMounts:
-        - name: workspace
-          mountPath: /workspace
-        - name: config
-          mountPath: /app/minimal-config
-        readinessProbe:
-          exec:
-            command:
-            - /bin/sh
-            - -c
-            - test -f /tmp/worker-ready
-          initialDelaySeconds: 30
-          periodSeconds: 10
-      volumes:
-      - name: workspace
-        emptyDir: {}
-      - name: config
-        configMap:
-          name: claude-config
-          optional: true
----
-# NodePort service for easy access
-apiVersion: v1
-kind: Service
-metadata:
-  name: bridge-nodeport
-  namespace: tribe-system
-spec:
-  type: NodePort
-  selector:
-    app: bridge
-  ports:
-  - name: http
-    port: 8080
-    nodePort: 30080
-  - name: websocket
-    port: 3456
-    nodePort: 30456
----
-# ConfigMap for Claude agent configuration
-apiVersion: v1
-kind: ConfigMap
-metadata:
-  name: claude-config
-  namespace: tribe-system
-data:
-  config.yaml: |
-    mcp_servers:
-      filesystem:
-        command: npx
-        args: ["-y", "@modelcontextprotocol/server-filesystem", "/workspace"]
-      git:
-        command: npx
-        args: ["-y", "@modelcontextprotocol/server-git"]
-        env:
-          PATH: /usr/local/bin:/usr/bin:/bin
----
-# Initialization Job
-apiVersion: batch/v1
-kind: Job
-metadata:
-  name: tribe-init
-  namespace: tribe-system
-spec:
-  template:
-    spec:
-      restartPolicy: OnFailure
-      containers:
-      - name: init
-        image: curlimages/curl:8.4.0
-        command: ['/bin/sh', '-c']
-        args:
-        - |
-          echo "Waiting for Gitea to be ready..."
-          until curl -s http://gitea:3000 > /dev/null; do
-            echo "Waiting for Gitea..."
-            sleep 5
-          done
-          
-          echo "Creating Gitea access token..."
-          TOKEN=$(curl -s -X POST http://gitea:3000/api/v1/users/gitea_admin/tokens \
-            -u gitea_admin:admin123 \
-            -H "Content-Type: application/json" \
-            -d '{"name":"taskmaster-'$(date +%s)'","scopes":["write:repository","write:user","write:issue","write:organization","read:repository"]}' \
-            | grep -o '"sha1":"[^"]*' | cut -d'"' -f4)
-          
-          if [ -z "$TOKEN" ]; then
-            echo "Failed to create token!"
-            exit 1
-          fi
-          
-          echo "Token created successfully"
-          
-          # Update TaskMaster with the token
-          echo "Updating TaskMaster configuration..."
-          curl -X POST http://taskmaster:5000/api/config \
-            -H "Content-Type: application/json" \
-            -d "{\"gitea_token\":\"$TOKEN\"}"
-          
-          echo "Initialization complete!"