gbos 1.3.20 → 1.3.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gbos",
-  "version": "1.3.20",
+  "version": "1.3.22",
   "description": "GBOS - Command line interface for GBOS services",
   "main": "src/index.js",
   "bin": {

package/src/cli.js

@@ -6,7 +6,9 @@ const program = new Command();
 const authCommand = require('./commands/auth');
 const connectCommand = require('./commands/connect');
 const logoutCommand = require('./commands/logout');
-const { tasksCommand, nextTaskCommand, continueCommand, fallbackCommand, addTaskCommand } = require('./commands/tasks');
+const { tasksCommand, nextTaskCommand, continueCommand, fallbackCommand, addTaskCommand, completedCommand } = require('./commands/tasks');
+const { syncStartCommand, syncStopCommand, syncStatusCommand, syncNowCommand, repoCreateCommand, repoListCommand, repoCloneCommand } = require('./commands/gitlab');
+const { registryLoginCommand, registryImagesCommand, registryPushCommand, registryPullCommand } = require('./commands/registry');
 const config = require('./lib/config');
 const { displayStatus, printBanner } = require('./lib/display');
 
@@ -118,6 +120,13 @@ program
   .description('Cancel work from the current task and revert to last completed state')
   .action(fallbackCommand);
 
+program
+  .command('completed')
+  .alias('done')
+  .description('Complete current task: commit, push to GitLab (creates repo if needed), and mark task done')
+  .option('-m, --message <message>', 'Custom commit message')
+  .action(completedCommand);
+
 program
   .command('add_task')
   .alias('add')
@@ -130,6 +139,101 @@ program
   .option('-a, --all', 'Clear all stored data including machine ID')
   .action(logoutCommand);
 
+// ==================== GitLab Commands ====================
+
+const gitlabCmd = program
+  .command('gitlab')
+  .description('GitLab integration commands');
+
+// GitLab Sync subcommands
+const gitlabSync = gitlabCmd
+  .command('sync')
+  .description('Auto-sync repository with GitLab');
+
+gitlabSync
+  .command('start')
+  .description('Start auto-syncing a repository')
+  .option('-p, --path <path>', 'Path to repository (defaults to current directory)')
+  .option('-i, --interval <seconds>', 'Sync interval in seconds (default: 60)', parseInt)
+  .action(syncStartCommand);
+
+gitlabSync
+  .command('stop')
+  .description('Stop auto-syncing a repository')
+  .option('-p, --path <path>', 'Path to repository (defaults to current directory)')
+  .option('-a, --all', 'Stop all active syncs')
+  .action(syncStopCommand);
+
+gitlabSync
+  .command('status')
+  .description('Show status of all active syncs')
+  .action(syncStatusCommand);
+
+gitlabSync
+  .command('now')
+  .description('Force an immediate sync')
+  .option('-p, --path <path>', 'Path to repository (defaults to current directory)')
+  .action(syncNowCommand);
+
+// GitLab Repo subcommands
+const gitlabRepo = gitlabCmd
+  .command('repo')
+  .description('GitLab repository management');
+
+gitlabRepo
+  .command('create <name>')
+  .description('Create a new GitLab repository')
+  .option('--private', 'Create as private repository (default)')
+  .option('--public', 'Create as public repository')
+  .option('-d, --description <description>', 'Repository description')
+  .option('--readme', 'Initialize with README')
+  .action(repoCreateCommand);
+
+gitlabRepo
+  .command('list')
+  .description('List GitLab repositories')
+  .option('-a, --all', 'Show all accessible repositories (not just owned)')
+  .action(repoListCommand);
+
+gitlabRepo
+  .command('clone <name>')
+  .description('Clone a GitLab repository')
+  .option('--ssh', 'Use SSH URL instead of HTTPS')
+  .option('-d, --dir <directory>', 'Target directory name')
+  .action(repoCloneCommand);
+
+// ==================== Registry Commands ====================
+
+const registryCmd = program
+  .command('registry')
+  .description('GitLab Container Registry commands');
+
+registryCmd
+  .command('login')
+  .description('Login to GitLab Container Registry')
+  .option('-r, --registry <url>', 'Registry URL (defaults to registry.gitlab.com)')
+  .action(registryLoginCommand);
+
+registryCmd
+  .command('images <project>')
+  .description('List container images in a project')
+  .option('-t, --tags', 'Show tags for each image')
+  .action(registryImagesCommand);
+
+registryCmd
+  .command('push <image>')
+  .description('Push an image to GitLab Container Registry')
+  .option('-p, --project <project>', 'GitLab project path (e.g., group/project)')
+  .option('-r, --registry <url>', 'Registry URL (defaults to registry.gitlab.com)')
+  .action(registryPushCommand);
+
+registryCmd
+  .command('pull <image>')
+  .description('Pull an image from GitLab Container Registry')
+  .option('-p, --project <project>', 'GitLab project path (e.g., group/project)')
+  .option('-r, --registry <url>', 'Registry URL (defaults to registry.gitlab.com)')
+  .action(registryPullCommand);
+
 program
   .command('help [command]')
   .description('Display help for a specific command')
@@ -140,7 +244,7 @@ program
         cmd.outputHelp();
       } else {
         console.log(`Unknown command: ${command}`);
-        console.log('Available commands: auth, connect, disconnect, status, tasks, next, continue, fallback, add_task, logout, help');
+        console.log('Available commands: auth, connect, disconnect, status, tasks, next, continue, completed, fallback, add_task, logout, gitlab, registry, help');
       }
     } else {
       program.outputHelp();

package/src/commands/gitlab.js

@@ -0,0 +1,470 @@
+const config = require('../lib/config');
+const { displayMessageBox, fg, LOGO_PURPLE, LOGO_LIGHT, RESET, BOLD, DIM, getTerminalWidth } = require('../lib/display');
+const { exec, spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Colors
+const CYAN = '\x1b[36m';
+const GREEN = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+const RED = '\x1b[31m';
+
+// GitLab configuration
+const GITLAB_CONFIG_FILE = path.join(os.homedir(), '.gbos', 'gitlab.json');
+const SYNC_PID_DIR = path.join(os.homedir(), '.gbos', 'sync');
+
+// Load GitLab config
+function loadGitLabConfig() {
+  try {
+    if (fs.existsSync(GITLAB_CONFIG_FILE)) {
+      return JSON.parse(fs.readFileSync(GITLAB_CONFIG_FILE, 'utf8'));
+    }
+  } catch (e) {
+    // Ignore errors
+  }
+  return { syncs: {}, repos: [] };
+}
+
+// Save GitLab config
+function saveGitLabConfig(config) {
+  const dir = path.dirname(GITLAB_CONFIG_FILE);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(GITLAB_CONFIG_FILE, JSON.stringify(config, null, 2), 'utf8');
+}
+
+// Get GitLab URL from session or config
+function getGitLabUrl() {
+  const session = config.loadSession();
+  return session?.gitlab_url || process.env.GITLAB_URL || 'https://gitlab.com';
+}
+
+// Get GitLab token
+function getGitLabToken() {
+  const session = config.loadSession();
+  return session?.gitlab_token || process.env.GITLAB_TOKEN || null;
+}
+
+// Execute git command
+function execGit(args, cwd = process.cwd()) {
+  return new Promise((resolve, reject) => {
+    exec(`git ${args}`, { cwd }, (error, stdout, stderr) => {
+      if (error) {
+        reject(new Error(stderr || error.message));
+      } else {
+        resolve(stdout.trim());
+      }
+    });
+  });
+}
+
+// ==================== SYNC COMMANDS ====================
+
+// Start auto-sync for a directory
+async function syncStartCommand(options) {
+  const targetPath = options.path || process.cwd();
+  const absolutePath = path.resolve(targetPath);
+
+  // Verify it's a git repository
+  try {
+    await execGit('rev-parse --is-inside-work-tree', absolutePath);
+  } catch (e) {
+    displayMessageBox('Not a Git Repository', `${absolutePath} is not a git repository.`, 'error');
+    process.exit(1);
+  }
+
+  // Get remote URL
+  let remoteUrl;
+  try {
+    remoteUrl = await execGit('remote get-url origin', absolutePath);
+  } catch (e) {
+    displayMessageBox('No Remote', 'No git remote "origin" configured.', 'error');
+    process.exit(1);
+  }
+
+  const interval = options.interval || 60; // Default 60 seconds
+
+  // Check if already syncing
+  const gitlabConfig = loadGitLabConfig();
+  if (gitlabConfig.syncs[absolutePath]) {
+    console.log(`\n${YELLOW}!${RESET} Sync already active for ${absolutePath}`);
+    console.log(`  ${DIM}Use "gbos gitlab sync stop" to stop it first.${RESET}\n`);
+    return;
+  }
+
+  // Create sync PID directory
+  if (!fs.existsSync(SYNC_PID_DIR)) {
+    fs.mkdirSync(SYNC_PID_DIR, { recursive: true });
+  }
+
+  // Start background sync process
+  const syncId = Date.now().toString();
+  const pidFile = path.join(SYNC_PID_DIR, `${syncId}.pid`);
+
+  // Create sync script
+  const syncScript = `
+    while true; do
+      cd "${absolutePath}"
+      git fetch origin 2>/dev/null
+      git add -A 2>/dev/null
+      CHANGES=$(git status --porcelain)
+      if [ -n "$CHANGES" ]; then
+        git commit -m "Auto-sync: $(date '+%Y-%m-%d %H:%M:%S')" 2>/dev/null
+        git push origin HEAD 2>/dev/null
+      fi
+      sleep ${interval}
+    done
+  `;
+
+  const child = spawn('bash', ['-c', syncScript], {
+    detached: true,
+    stdio: 'ignore',
+  });
+
+  child.unref();
+
+  // Save PID
+  fs.writeFileSync(pidFile, child.pid.toString(), 'utf8');
+
+  // Update config
+  gitlabConfig.syncs[absolutePath] = {
+    syncId,
+    pid: child.pid,
+    pidFile,
+    remote: remoteUrl,
+    interval,
+    startedAt: new Date().toISOString(),
+  };
+  saveGitLabConfig(gitlabConfig);
+
+  console.log(`\n${GREEN}✓${RESET} ${BOLD}Auto-sync started${RESET}`);
+  console.log(`  ${DIM}Path:${RESET}     ${absolutePath}`);
+  console.log(`  ${DIM}Remote:${RESET}   ${remoteUrl}`);
+  console.log(`  ${DIM}Interval:${RESET} ${interval} seconds`);
+  console.log(`  ${DIM}PID:${RESET}      ${child.pid}\n`);
+  console.log(`  ${DIM}Use "gbos gitlab sync stop" to stop syncing.${RESET}\n`);
+}
+
+// Stop auto-sync
+async function syncStopCommand(options) {
+  const targetPath = options.path ? path.resolve(options.path) : process.cwd();
+
+  const gitlabConfig = loadGitLabConfig();
+
+  // Find sync for this path or stop all
+  let syncsToStop = [];
+
+  if (options.all) {
+    syncsToStop = Object.entries(gitlabConfig.syncs);
+  } else if (gitlabConfig.syncs[targetPath]) {
+    syncsToStop = [[targetPath, gitlabConfig.syncs[targetPath]]];
+  } else {
+    console.log(`\n${DIM}No active sync for ${targetPath}${RESET}\n`);
+    return;
+  }
+
+  for (const [syncPath, syncInfo] of syncsToStop) {
+    try {
+      // Kill the process
+      process.kill(syncInfo.pid, 'SIGTERM');
+    } catch (e) {
+      // Process may already be dead
+    }
+
+    // Remove PID file
+    try {
+      if (fs.existsSync(syncInfo.pidFile)) {
+        fs.unlinkSync(syncInfo.pidFile);
+      }
+    } catch (e) {
+      // Ignore
+    }
+
+    // Remove from config
+    delete gitlabConfig.syncs[syncPath];
+
+    console.log(`${GREEN}✓${RESET} Stopped sync for ${syncPath}`);
+  }
+
+  saveGitLabConfig(gitlabConfig);
+  console.log('');
+}
+
+// Show sync status
+async function syncStatusCommand() {
+  const gitlabConfig = loadGitLabConfig();
+  const syncs = Object.entries(gitlabConfig.syncs);
+
+  const termWidth = getTerminalWidth();
+  const tableWidth = Math.min(100, termWidth - 4);
+
+  console.log(`\n${fg(...LOGO_PURPLE)}${'─'.repeat(tableWidth)}${RESET}`);
+  console.log(`${BOLD}  Active Syncs${RESET}`);
+  console.log(`${fg(...LOGO_PURPLE)}${'─'.repeat(tableWidth)}${RESET}\n`);
+
+  if (syncs.length === 0) {
+    console.log(`  ${DIM}No active syncs.${RESET}`);
+    console.log(`  ${DIM}Use "gbos gitlab sync start" to start syncing a repository.${RESET}\n`);
+  } else {
+    for (const [syncPath, syncInfo] of syncs) {
+      // Check if process is still running
+      let isRunning = false;
+      try {
+        process.kill(syncInfo.pid, 0);
+        isRunning = true;
+      } catch (e) {
+        isRunning = false;
+      }
+
+      const status = isRunning ? `${GREEN}● running${RESET}` : `${RED}● stopped${RESET}`;
+      console.log(`  ${status}  ${BOLD}${syncPath}${RESET}`);
+      console.log(`     ${DIM}Remote: ${syncInfo.remote}${RESET}`);
+      console.log(`     ${DIM}Interval: ${syncInfo.interval}s | PID: ${syncInfo.pid}${RESET}`);
+      console.log(`     ${DIM}Started: ${new Date(syncInfo.startedAt).toLocaleString()}${RESET}`);
+      console.log('');
+    }
+  }
+
+  console.log(`${fg(...LOGO_PURPLE)}${'─'.repeat(tableWidth)}${RESET}\n`);
+}
+
+// Force immediate sync
+async function syncNowCommand(options) {
+  const targetPath = options.path ? path.resolve(options.path) : process.cwd();
+
+  // Verify it's a git repository
+  try {
+    await execGit('rev-parse --is-inside-work-tree', targetPath);
+  } catch (e) {
+    displayMessageBox('Not a Git Repository', `${targetPath} is not a git repository.`, 'error');
+    process.exit(1);
+  }
+
+  console.log(`\n${DIM}Syncing ${targetPath}...${RESET}\n`);
+
+  try {
+    // Fetch from remote
+    console.log(`  ${DIM}Fetching from origin...${RESET}`);
+    await execGit('fetch origin', targetPath);
+
+    // Stage all changes
+    console.log(`  ${DIM}Staging changes...${RESET}`);
+    await execGit('add -A', targetPath);
+
+    // Check for changes
+    const status = await execGit('status --porcelain', targetPath);
+
+    if (status) {
+      // Commit changes
+      const commitMsg = `Manual sync: ${new Date().toISOString()}`;
+      console.log(`  ${DIM}Committing changes...${RESET}`);
+      await execGit(`commit -m "${commitMsg}"`, targetPath);
+
+      // Push to remote
+      console.log(`  ${DIM}Pushing to origin...${RESET}`);
+      await execGit('push origin HEAD', targetPath);
+
+      console.log(`\n${GREEN}✓${RESET} ${BOLD}Sync complete${RESET} - Changes pushed to remote.\n`);
+    } else {
+      console.log(`\n${GREEN}✓${RESET} ${BOLD}Already in sync${RESET} - No local changes to push.\n`);
+    }
+
+    // Pull any remote changes
+    try {
+      console.log(`  ${DIM}Pulling remote changes...${RESET}`);
+      await execGit('pull origin HEAD --rebase', targetPath);
+    } catch (e) {
+      // May fail if there are conflicts
+      console.log(`  ${YELLOW}!${RESET} ${DIM}Could not pull remote changes (may have conflicts).${RESET}`);
+    }
+
+  } catch (error) {
+    displayMessageBox('Sync Failed', error.message, 'error');
+    process.exit(1);
+  }
+}
+
+// ==================== REPO COMMANDS ====================
+
+// Create a new repository
+async function repoCreateCommand(name, options) {
+  const token = getGitLabToken();
+  const gitlabUrl = getGitLabUrl();
+
+  if (!token) {
+    displayMessageBox('Not Configured', 'GitLab token not configured. Set GITLAB_TOKEN environment variable.', 'error');
+    process.exit(1);
+  }
+
+  const visibility = options.private ? 'private' : (options.public ? 'public' : 'private');
+  const description = options.description || '';
+
+  console.log(`\n${DIM}Creating repository "${name}" on GitLab...${RESET}\n`);
+
+  try {
+    const response = await fetch(`${gitlabUrl}/api/v4/projects`, {
+      method: 'POST',
+      headers: {
+        'PRIVATE-TOKEN': token,
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        name,
+        description,
+        visibility,
+        initialize_with_readme: options.readme || false,
+      }),
+    });
+
+    if (!response.ok) {
+      const error = await response.json();
+      throw new Error(error.message || `Failed to create repository: ${response.status}`);
+    }
+
+    const repo = await response.json();
+
+    console.log(`${GREEN}✓${RESET} ${BOLD}Repository created${RESET}`);
+    console.log(`  ${DIM}Name:${RESET}       ${repo.name}`);
+    console.log(`  ${DIM}URL:${RESET}        ${repo.web_url}`);
+    console.log(`  ${DIM}Clone SSH:${RESET}  ${repo.ssh_url_to_repo}`);
+    console.log(`  ${DIM}Clone HTTP:${RESET} ${repo.http_url_to_repo}`);
+    console.log(`  ${DIM}Visibility:${RESET} ${repo.visibility}\n`);
+
+    // Save to config
+    const gitlabConfig = loadGitLabConfig();
+    gitlabConfig.repos.push({
+      id: repo.id,
+      name: repo.name,
+      path: repo.path_with_namespace,
+      url: repo.web_url,
+      ssh_url: repo.ssh_url_to_repo,
+      http_url: repo.http_url_to_repo,
+      createdAt: new Date().toISOString(),
+    });
+    saveGitLabConfig(gitlabConfig);
+
+  } catch (error) {
+    displayMessageBox('Failed', error.message, 'error');
+    process.exit(1);
+  }
+}
+
+// List repositories
+async function repoListCommand(options) {
+  const token = getGitLabToken();
+  const gitlabUrl = getGitLabUrl();
+
+  if (!token) {
+    displayMessageBox('Not Configured', 'GitLab token not configured. Set GITLAB_TOKEN environment variable.', 'error');
+    process.exit(1);
+  }
+
+  console.log(`\n${DIM}Fetching repositories from GitLab...${RESET}\n`);
+
+  try {
+    const owned = options.all ? '' : '&owned=true';
+    const response = await fetch(`${gitlabUrl}/api/v4/projects?per_page=50${owned}`, {
+      headers: {
+        'PRIVATE-TOKEN': token,
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(`Failed to list repositories: ${response.status}`);
+    }
+
+    const repos = await response.json();
+
+    const termWidth = getTerminalWidth();
+    const tableWidth = Math.min(100, termWidth - 4);
+
+    console.log(`${fg(...LOGO_PURPLE)}${'─'.repeat(tableWidth)}${RESET}`);
+    console.log(`${BOLD}  GitLab Repositories${RESET}`);
+    console.log(`${fg(...LOGO_PURPLE)}${'─'.repeat(tableWidth)}${RESET}\n`);
+
+    if (repos.length === 0) {
+      console.log(`  ${DIM}No repositories found.${RESET}\n`);
+    } else {
+      repos.forEach((repo, i) => {
+        const visibility = repo.visibility === 'private' ? `${YELLOW}private${RESET}` : `${GREEN}${repo.visibility}${RESET}`;
+        console.log(`  ${CYAN}${i + 1}.${RESET} ${BOLD}${repo.path_with_namespace}${RESET} (${visibility})`);
+        if (repo.description) {
+          console.log(`     ${DIM}${repo.description.substring(0, 60)}${repo.description.length > 60 ? '...' : ''}${RESET}`);
+        }
+        console.log(`     ${DIM}${repo.http_url_to_repo}${RESET}`);
+        if (i < repos.length - 1) console.log('');
+      });
+    }
+
+    console.log(`\n${fg(...LOGO_PURPLE)}${'─'.repeat(tableWidth)}${RESET}`);
+    console.log(`${DIM}  Total: ${repos.length} repository(ies)${RESET}\n`);
+
+  } catch (error) {
+    displayMessageBox('Failed', error.message, 'error');
+    process.exit(1);
+  }
+}
+
+// Clone a repository
+async function repoCloneCommand(name, options) {
+  const token = getGitLabToken();
+  const gitlabUrl = getGitLabUrl();
+
+  if (!token) {
+    displayMessageBox('Not Configured', 'GitLab token not configured. Set GITLAB_TOKEN environment variable.', 'error');
+    process.exit(1);
+  }
+
+  console.log(`\n${DIM}Searching for repository "${name}"...${RESET}\n`);
+
+  try {
+    // Search for repository
+    const response = await fetch(`${gitlabUrl}/api/v4/projects?search=${encodeURIComponent(name)}`, {
+      headers: {
+        'PRIVATE-TOKEN': token,
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(`Failed to search repositories: ${response.status}`);
+    }
+
+    const repos = await response.json();
+
+    if (repos.length === 0) {
+      displayMessageBox('Not Found', `Repository "${name}" not found.`, 'error');
+      process.exit(1);
+    }
+
+    // Find exact match or use first result
+    const repo = repos.find(r => r.name === name || r.path_with_namespace === name) || repos[0];
+
+    const cloneUrl = options.ssh ? repo.ssh_url_to_repo : repo.http_url_to_repo;
+    const targetDir = options.dir || repo.name;
+
+    console.log(`  ${DIM}Cloning ${repo.path_with_namespace}...${RESET}`);
+    console.log(`  ${DIM}URL: ${cloneUrl}${RESET}\n`);
+
+    await execGit(`clone ${cloneUrl} ${targetDir}`);
+
+    console.log(`${GREEN}✓${RESET} ${BOLD}Repository cloned${RESET}`);
+    console.log(`  ${DIM}Location:${RESET} ${path.resolve(targetDir)}\n`);
+
+  } catch (error) {
+    displayMessageBox('Clone Failed', error.message, 'error');
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  syncStartCommand,
+  syncStopCommand,
+  syncStatusCommand,
+  syncNowCommand,
+  repoCreateCommand,
+  repoListCommand,
+  repoCloneCommand,
+};

package/src/commands/registry.js

@@ -0,0 +1,314 @@
+const config = require('../lib/config');
+const { displayMessageBox, fg, LOGO_PURPLE, LOGO_LIGHT, RESET, BOLD, DIM, getTerminalWidth } = require('../lib/display');
+const { exec, spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Colors
+const CYAN = '\x1b[36m';
+const GREEN = '\x1b[32m';
+const YELLOW = '\x1b[33m';
+const RED = '\x1b[31m';
+
+// Get GitLab URL from session or config
+function getGitLabUrl() {
+  const session = config.loadSession();
+  return session?.gitlab_url || process.env.GITLAB_URL || 'https://gitlab.com';
+}
+
+// Get GitLab token
+function getGitLabToken() {
+  const session = config.loadSession();
+  return session?.gitlab_token || process.env.GITLAB_TOKEN || null;
+}
+
+// Get registry URL from GitLab URL
+function getRegistryUrl() {
+  const gitlabUrl = getGitLabUrl();
+  try {
+    const url = new URL(gitlabUrl);
+    return `registry.${url.hostname}`;
+  } catch (e) {
+    return 'registry.gitlab.com';
+  }
+}
+
+// Execute shell command
+function execCommand(command, options = {}) {
+  return new Promise((resolve, reject) => {
+    exec(command, options, (error, stdout, stderr) => {
+      if (error) {
+        reject(new Error(stderr || error.message));
+      } else {
+        resolve({ stdout: stdout.trim(), stderr: stderr.trim() });
+      }
+    });
+  });
+}
+
+// ==================== REGISTRY COMMANDS ====================
+
+// Login to GitLab Container Registry
+async function registryLoginCommand(options) {
+  const token = getGitLabToken();
+  const registryUrl = options.registry || getRegistryUrl();
+
+  if (!token) {
+    displayMessageBox('Not Configured', 'GitLab token not configured. Set GITLAB_TOKEN environment variable or run "gbos auth" first.', 'error');
+    process.exit(1);
+  }
+
+  console.log(`\n${DIM}Logging into GitLab Container Registry...${RESET}\n`);
+  console.log(`  ${DIM}Registry:${RESET} ${registryUrl}`);
+
+  try {
+    // Use docker login with token
+    const loginProcess = spawn('docker', ['login', registryUrl, '-u', 'oauth2', '--password-stdin'], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    loginProcess.stdout.on('data', (data) => {
+      stdout += data.toString();
+    });
+
+    loginProcess.stderr.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    // Write token to stdin
+    loginProcess.stdin.write(token);
+    loginProcess.stdin.end();
+
+    await new Promise((resolve, reject) => {
+      loginProcess.on('close', (code) => {
+        if (code === 0) {
+          resolve();
+        } else {
+          reject(new Error(stderr || `Docker login failed with code ${code}`));
+        }
+      });
+    });
+
+    console.log(`\n${GREEN}✓${RESET} ${BOLD}Login successful${RESET}`);
+    console.log(`  ${DIM}You can now push and pull images from ${registryUrl}${RESET}\n`);
+
+  } catch (error) {
+    // Check if docker is installed
+    try {
+      await execCommand('docker --version');
+    } catch (e) {
+      displayMessageBox('Docker Not Found', 'Docker is not installed or not in PATH. Please install Docker first.', 'error');
+      process.exit(1);
+    }
+
+    displayMessageBox('Login Failed', error.message, 'error');
+    process.exit(1);
+  }
+}
+
+// List container images in a project
+async function registryImagesCommand(project, options) {
+  const token = getGitLabToken();
+  const gitlabUrl = getGitLabUrl();
+
+  if (!token) {
+    displayMessageBox('Not Configured', 'GitLab token not configured. Set GITLAB_TOKEN environment variable.', 'error');
+    process.exit(1);
+  }
+
+  // URL encode the project path
+  const encodedProject = encodeURIComponent(project);
+
+  console.log(`\n${DIM}Fetching container images for "${project}"...${RESET}\n`);
+
+  try {
+    // First get the project to verify it exists
+    const projectResponse = await fetch(`${gitlabUrl}/api/v4/projects/${encodedProject}`, {
+      headers: {
+        'PRIVATE-TOKEN': token,
+      },
+    });
+
+    if (!projectResponse.ok) {
+      if (projectResponse.status === 404) {
+        throw new Error(`Project "${project}" not found. Use the full path like "group/project".`);
+      }
+      throw new Error(`Failed to fetch project: ${projectResponse.status}`);
+    }
+
+    const projectData = await projectResponse.json();
+
+    // Get container repositories
+    const reposResponse = await fetch(`${gitlabUrl}/api/v4/projects/${projectData.id}/registry/repositories`, {
+      headers: {
+        'PRIVATE-TOKEN': token,
+      },
+    });
+
+    if (!reposResponse.ok) {
+      throw new Error(`Failed to fetch repositories: ${reposResponse.status}`);
+    }
+
+    const repos = await reposResponse.json();
+
+    const termWidth = getTerminalWidth();
+    const tableWidth = Math.min(100, termWidth - 4);
+
+    console.log(`${fg(...LOGO_PURPLE)}${'─'.repeat(tableWidth)}${RESET}`);
+    console.log(`${BOLD}  Container Images - ${projectData.path_with_namespace}${RESET}`);
+    console.log(`${fg(...LOGO_PURPLE)}${'─'.repeat(tableWidth)}${RESET}\n`);
+
+    if (repos.length === 0) {
+      console.log(`  ${DIM}No container images found.${RESET}`);
+      console.log(`  ${DIM}Push an image with: docker push ${getRegistryUrl()}/${projectData.path_with_namespace}/<image>:<tag>${RESET}\n`);
+    } else {
+      for (const repo of repos) {
+        console.log(`  ${CYAN}●${RESET} ${BOLD}${repo.path}${RESET}`);
+        console.log(`    ${DIM}ID: ${repo.id} | Location: ${repo.location}${RESET}`);
+
+        // Get tags for this repository
+        if (options.tags) {
+          try {
+            const tagsResponse = await fetch(`${gitlabUrl}/api/v4/projects/${projectData.id}/registry/repositories/${repo.id}/tags`, {
+              headers: {
+                'PRIVATE-TOKEN': token,
+              },
+            });
+
+            if (tagsResponse.ok) {
+              const tags = await tagsResponse.json();
+              if (tags.length > 0) {
+                const tagList = tags.slice(0, 10).map(t => t.name).join(', ');
+                console.log(`    ${DIM}Tags: ${tagList}${tags.length > 10 ? ` (+${tags.length - 10} more)` : ''}${RESET}`);
+              }
+            }
+          } catch (e) {
+            // Ignore tag fetch errors
+          }
+        }
+
+        console.log('');
+      }
+    }
+
+    console.log(`${fg(...LOGO_PURPLE)}${'─'.repeat(tableWidth)}${RESET}`);
+    console.log(`${DIM}  Total: ${repos.length} image(s)${RESET}\n`);
+
+  } catch (error) {
+    displayMessageBox('Failed', error.message, 'error');
+    process.exit(1);
+  }
+}
+
+// Push an image to GitLab Container Registry
+async function registryPushCommand(image, options) {
+  const registryUrl = options.registry || getRegistryUrl();
+
+  console.log(`\n${DIM}Pushing image to GitLab Container Registry...${RESET}\n`);
+
+  // Check if the image name already includes the registry
+  let fullImage = image;
+  if (!image.includes('/') || !image.includes('.')) {
+    // User provided just an image name, need project path
+    if (!options.project) {
+      displayMessageBox('Project Required', 'Please specify the project with --project or use full image path.\n\nExample: gbos registry push myimage:latest --project group/project\nOr: gbos registry push registry.gitlab.com/group/project/image:tag', 'error');
+      process.exit(1);
+    }
+    fullImage = `${registryUrl}/${options.project}/${image}`;
+  }
+
+  console.log(`  ${DIM}Image:${RESET}    ${image}`);
+  console.log(`  ${DIM}Target:${RESET}   ${fullImage}\n`);
+
+  try {
+    // Tag the image if needed
+    if (fullImage !== image) {
+      console.log(`  ${DIM}Tagging image...${RESET}`);
+      await execCommand(`docker tag ${image} ${fullImage}`);
+    }
+
+    // Push the image
+    console.log(`  ${DIM}Pushing to registry...${RESET}\n`);
+
+    const pushProcess = spawn('docker', ['push', fullImage], {
+      stdio: 'inherit',
+    });
+
+    await new Promise((resolve, reject) => {
+      pushProcess.on('close', (code) => {
+        if (code === 0) {
+          resolve();
+        } else {
+          reject(new Error(`Push failed with exit code ${code}`));
+        }
+      });
+    });
+
+    console.log(`\n${GREEN}✓${RESET} ${BOLD}Image pushed successfully${RESET}`);
+    console.log(`  ${DIM}Location:${RESET} ${fullImage}\n`);
+
+  } catch (error) {
+    // Check if docker is installed
+    try {
+      await execCommand('docker --version');
+    } catch (e) {
+      displayMessageBox('Docker Not Found', 'Docker is not installed or not in PATH. Please install Docker first.', 'error');
+      process.exit(1);
+    }
+
+    displayMessageBox('Push Failed', error.message, 'error');
+    process.exit(1);
+  }
+}
+
+// Pull an image from GitLab Container Registry
+async function registryPullCommand(image, options) {
+  const registryUrl = options.registry || getRegistryUrl();
+
+  console.log(`\n${DIM}Pulling image from GitLab Container Registry...${RESET}\n`);
+
+  // Check if the image name already includes the registry
+  let fullImage = image;
+  if (!image.includes('/') || !image.includes('.')) {
+    if (!options.project) {
+      displayMessageBox('Project Required', 'Please specify the project with --project or use full image path.', 'error');
+      process.exit(1);
+    }
+    fullImage = `${registryUrl}/${options.project}/${image}`;
+  }
+
+  console.log(`  ${DIM}Pulling:${RESET} ${fullImage}\n`);
+
+  try {
+    const pullProcess = spawn('docker', ['pull', fullImage], {
+      stdio: 'inherit',
+    });
+
+    await new Promise((resolve, reject) => {
+      pullProcess.on('close', (code) => {
+        if (code === 0) {
+          resolve();
+        } else {
+          reject(new Error(`Pull failed with exit code ${code}`));
+        }
+      });
+    });
+
+    console.log(`\n${GREEN}✓${RESET} ${BOLD}Image pulled successfully${RESET}\n`);
+
+  } catch (error) {
+    displayMessageBox('Pull Failed', error.message, 'error');
+    process.exit(1);
+  }
+}
+
+module.exports = {
+  registryLoginCommand,
+  registryImagesCommand,
+  registryPushCommand,
+  registryPullCommand,
+};

package/src/commands/tasks.js

@@ -2,6 +2,9 @@ const api = require('../lib/api');
 const config = require('../lib/config');
 const { displayMessageBox, printBanner, printStatusTable, fg, LOGO_LIGHT, LOGO_PURPLE, RESET, BOLD, DIM, getTerminalWidth } = require('../lib/display');
 const readline = require('readline');
+const { exec, spawn } = require('child_process');
+const path = require('path');
+const fs = require('fs');
 
 // Colors for prompts
 const CYAN = '\x1b[36m';
@@ -697,11 +700,265 @@ async function addTaskCommand() {
   }
 }
 
+// Execute git command
+function execGit(args, cwd = process.cwd()) {
+  return new Promise((resolve, reject) => {
+    exec(`git ${args}`, { cwd, maxBuffer: 10 * 1024 * 1024 }, (error, stdout, stderr) => {
+      if (error) {
+        reject(new Error(stderr || error.message));
+      } else {
+        resolve(stdout.trim());
+      }
+    });
+  });
+}
+
+// Get GitLab URL and token from session or env
+function getGitLabConfig() {
+  const session = config.loadSession();
+  return {
+    url: session?.gitlab_url || process.env.GITLAB_URL || 'https://gitlab.com',
+    token: session?.gitlab_token || process.env.GITLAB_TOKEN || null,
+  };
+}
+
+// Completed command - commit, push, and complete task
+async function completedCommand(options) {
+  const cwd = process.cwd();
+  const dirName = path.basename(cwd);
+
+  console.log(`\n${DIM}Processing completion...${RESET}\n`);
+
+  // Step 1: Check if current directory is a git repo
+  let isGitRepo = false;
+  let hasRemote = false;
+  let remoteUrl = '';
+
+  try {
+    await execGit('rev-parse --is-inside-work-tree', cwd);
+    isGitRepo = true;
+    console.log(`  ${GREEN}✓${RESET} Git repository detected`);
+
+    // Check for remote
+    try {
+      remoteUrl = await execGit('remote get-url origin', cwd);
+      hasRemote = true;
+      console.log(`  ${GREEN}✓${RESET} Remote: ${remoteUrl}`);
+    } catch (e) {
+      hasRemote = false;
+      console.log(`  ${YELLOW}!${RESET} No remote configured`);
+    }
+  } catch (e) {
+    isGitRepo = false;
+    console.log(`  ${YELLOW}!${RESET} Not a git repository`);
+  }
+
+  // Step 2: Initialize git if needed
+  if (!isGitRepo) {
+    console.log(`\n  ${DIM}Initializing git repository...${RESET}`);
+    try {
+      await execGit('init', cwd);
+      isGitRepo = true;
+      console.log(`  ${GREEN}✓${RESET} Git repository initialized`);
+    } catch (e) {
+      displayMessageBox('Error', `Failed to initialize git: ${e.message}`, 'error');
+      process.exit(1);
+    }
+  }
+
+  // Step 3: Create GitLab repo if no remote
+  if (!hasRemote) {
+    const gitlab = getGitLabConfig();
+
+    if (!gitlab.token) {
+      console.log(`\n  ${YELLOW}!${RESET} No GitLab token configured.`);
+      console.log(`  ${DIM}Set GITLAB_TOKEN environment variable to auto-create repos.${RESET}`);
+      console.log(`  ${DIM}Skipping remote setup...${RESET}\n`);
+    } else {
+      console.log(`\n  ${DIM}Creating GitLab repository "${dirName}"...${RESET}`);
+
+      try {
+        const response = await fetch(`${gitlab.url}/api/v4/projects`, {
+          method: 'POST',
+          headers: {
+            'PRIVATE-TOKEN': gitlab.token,
+            'Content-Type': 'application/json',
+          },
+          body: JSON.stringify({
+            name: dirName,
+            visibility: 'private',
+            initialize_with_readme: false,
+          }),
+        });
+
+        if (response.ok) {
+          const repo = await response.json();
+          remoteUrl = repo.ssh_url_to_repo || repo.http_url_to_repo;
+
+          // Add remote
+          await execGit(`remote add origin ${remoteUrl}`, cwd);
+          hasRemote = true;
+
+          console.log(`  ${GREEN}✓${RESET} GitLab repository created: ${repo.web_url}`);
+          console.log(`  ${GREEN}✓${RESET} Remote added: ${remoteUrl}`);
+        } else {
+          const error = await response.json();
+          if (error.message && error.message.includes('has already been taken')) {
+            // Repo exists, try to find and add it
+            console.log(`  ${YELLOW}!${RESET} Repository "${dirName}" already exists on GitLab`);
+
+            // Try to get user info and construct URL
+            try {
+              const userResponse = await fetch(`${gitlab.url}/api/v4/user`, {
+                headers: { 'PRIVATE-TOKEN': gitlab.token },
+              });
+              if (userResponse.ok) {
+                const user = await userResponse.json();
+                remoteUrl = `git@${new URL(gitlab.url).hostname}:${user.username}/${dirName}.git`;
+                await execGit(`remote add origin ${remoteUrl}`, cwd);
+                hasRemote = true;
+                console.log(`  ${GREEN}✓${RESET} Remote added: ${remoteUrl}`);
+              }
+            } catch (e) {
+              console.log(`  ${DIM}Could not auto-configure remote. Add manually with:${RESET}`);
+              console.log(`  ${DIM}git remote add origin <your-repo-url>${RESET}`);
+            }
+          } else {
+            console.log(`  ${YELLOW}!${RESET} Failed to create repo: ${error.message || response.status}`);
+          }
+        }
+      } catch (e) {
+        console.log(`  ${YELLOW}!${RESET} Failed to create GitLab repo: ${e.message}`);
+      }
+    }
+  }
+
+  // Step 4: Stage all changes
+  console.log(`\n  ${DIM}Staging changes...${RESET}`);
+  try {
+    await execGit('add -A', cwd);
+    console.log(`  ${GREEN}✓${RESET} Changes staged`);
+  } catch (e) {
+    console.log(`  ${YELLOW}!${RESET} Failed to stage: ${e.message}`);
+  }
+
+  // Step 5: Check for changes to commit
+  let hasChanges = false;
+  try {
+    const status = await execGit('status --porcelain', cwd);
+    hasChanges = status.length > 0;
+  } catch (e) {
+    // Assume changes exist
+    hasChanges = true;
+  }
+
+  // Step 6: Commit changes
+  if (hasChanges) {
+    console.log(`  ${DIM}Committing changes...${RESET}`);
+
+    // Get current task for commit message
+    let taskInfo = '';
+    try {
+      if (config.isAuthenticated() && config.getConnection()) {
+        const currentResponse = await api.getCurrentTask();
+        const task = currentResponse.data?.task || currentResponse.data;
+        if (task) {
+          taskInfo = task.task_key ? `[${task.task_key}] ` : `[Task #${task.id}] `;
+        }
+      }
+    } catch (e) {
+      // No task info available
+    }
+
+    const timestamp = new Date().toISOString().replace('T', ' ').substring(0, 19);
+    const commitMessage = options.message || `${taskInfo}Completed: ${timestamp}`;
+
+    try {
+      await execGit(`commit -m "${commitMessage.replace(/"/g, '\\"')}"`, cwd);
+      console.log(`  ${GREEN}✓${RESET} Changes committed: "${commitMessage}"`);
+    } catch (e) {
+      if (e.message.includes('nothing to commit')) {
+        console.log(`  ${DIM}No changes to commit${RESET}`);
+      } else {
+        console.log(`  ${YELLOW}!${RESET} Commit failed: ${e.message}`);
+      }
+    }
+  } else {
+    console.log(`  ${DIM}No changes to commit${RESET}`);
+  }
+
+  // Step 7: Push to remote
+  if (hasRemote) {
+    console.log(`  ${DIM}Pushing to remote...${RESET}`);
+    try {
+      // Try to get current branch
+      let branch = 'main';
+      try {
+        branch = await execGit('rev-parse --abbrev-ref HEAD', cwd);
+      } catch (e) {
+        branch = 'main';
+      }
+
+      // Push with upstream tracking
+      try {
+        await execGit(`push -u origin ${branch}`, cwd);
+        console.log(`  ${GREEN}✓${RESET} Pushed to origin/${branch}`);
+      } catch (e) {
+        // If push fails, try setting upstream
+        if (e.message.includes('no upstream branch')) {
+          await execGit(`push --set-upstream origin ${branch}`, cwd);
+          console.log(`  ${GREEN}✓${RESET} Pushed to origin/${branch}`);
+        } else {
+          throw e;
+        }
+      }
+    } catch (e) {
+      console.log(`  ${YELLOW}!${RESET} Push failed: ${e.message}`);
+      console.log(`  ${DIM}You may need to push manually with: git push -u origin main${RESET}`);
+    }
+  }
+
+  // Step 8: Mark GBOS task as complete (if authenticated and connected)
+  if (config.isAuthenticated() && config.getConnection()) {
+    try {
+      const currentResponse = await api.getCurrentTask();
+      const task = currentResponse.data?.task || currentResponse.data;
+
+      if (task && task.status === 'in_progress') {
+        console.log(`\n  ${DIM}Marking GBOS task as complete...${RESET}`);
+        await api.completeTask(task.id, {
+          completion_notes: options.message || 'Completed via gbos completed command',
+        });
+        console.log(`  ${GREEN}✓${RESET} Task "${task.title || task.id}" marked as complete`);
+      }
+    } catch (e) {
+      // Task completion is optional, don't fail the whole command
+      if (e.status !== 404) {
+        console.log(`  ${DIM}Note: Could not update GBOS task status${RESET}`);
+      }
+    }
+  }
+
+  // Final summary
+  const termWidth = getTerminalWidth();
+  const tableWidth = Math.min(60, termWidth - 4);
+
+  console.log(`\n${fg(...LOGO_PURPLE)}${'─'.repeat(tableWidth)}${RESET}`);
+  console.log(`${GREEN}✓${RESET} ${BOLD}Completion finished!${RESET}`);
+  console.log(`${fg(...LOGO_PURPLE)}${'─'.repeat(tableWidth)}${RESET}\n`);
+
+  if (remoteUrl) {
+    console.log(`  ${DIM}Repository:${RESET} ${remoteUrl}`);
+  }
+  console.log(`  ${DIM}Run "gbos continue" to start the next task.${RESET}\n`);
+}
+
 module.exports = {
   tasksCommand,
   nextTaskCommand,
   continueCommand,
   fallbackCommand,
   addTaskCommand,
+  completedCommand,
   generateAgentPrompt,
 };