datagrok-tools 5.1.9 → 6.0.0

package/bin/commands/claude.js

@@ -0,0 +1,613 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.claude = claude;
+var _child_process = require("child_process");
+var _fs = _interopRequireDefault(require("fs"));
+var _http = _interopRequireDefault(require("http"));
+var _net = _interopRequireDefault(require("net"));
+var _os = _interopRequireDefault(require("os"));
+var _path = _interopRequireDefault(require("path"));
+var color = _interopRequireWildcard(require("../utils/color-utils"));
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/** Convert a Windows path to Docker-compatible forward-slash format. */
+function toDockerPath(p) {
+  return p.replace(/\\/g, '/');
+}
+
+/** Ensure a directory exists on the host before bind-mounting it. */
+function ensureDir(dir) {
+  if (!_fs.default.existsSync(dir)) _fs.default.mkdirSync(dir, {
+    recursive: true
+  });
+}
+
+/**
+ * Locate the host Claude config directory by searching multiple candidate paths.
+ * Mirrors the search logic from deploy/fat_dev/dg-claude.
+ * Returns the path to the .claude directory, or undefined if not found.
+ */
+function findClaudeHome() {
+  const candidates = [];
+
+  // 1. Explicit CLAUDE_HOME env var
+  if (process.env.CLAUDE_HOME) candidates.push(process.env.CLAUDE_HOME);
+
+  // 2. OS home directory
+  const home = _os.default.homedir();
+  candidates.push(_path.default.join(home, '.claude'));
+
+  // 3. USERPROFILE (Windows — may differ from homedir in some setups)
+  if (process.env.USERPROFILE) candidates.push(_path.default.join(process.env.USERPROFILE, '.claude'));
+
+  // 4. APPDATA fallback (Windows: %APPDATA%/../.claude)
+  if (process.env.APPDATA) candidates.push(_path.default.join(process.env.APPDATA, '..', '.claude'));
+  for (const candidate of candidates) {
+    if (!candidate) continue;
+    const resolved = _path.default.resolve(candidate);
+    if (_fs.default.existsSync(_path.default.join(resolved, '.credentials.json'))) return resolved;
+  }
+
+  // Fall back to the first existing .claude directory even without .credentials.json
+  for (const candidate of candidates) {
+    if (!candidate) continue;
+    const resolved = _path.default.resolve(candidate);
+    if (_fs.default.existsSync(resolved) && _fs.default.statSync(resolved).isDirectory()) return resolved;
+  }
+  return undefined;
+}
+const COMPOSE_TEMPLATE = `# Generated by grok claude — do not edit
+services:
+  postgres:
+    image: pgvector/pgvector:pg17
+    command: postgres -c 'max_connections=1000'
+    environment:
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: postgres
+    volumes:
+      - pgdata:/var/lib/postgresql/data
+    shm_size: 2gb
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U postgres"]
+      interval: 5s
+      retries: 10
+    networks:
+      dg:
+        aliases: [database, postgres]
+    restart: unless-stopped
+
+  rabbitmq:
+    image: rabbitmq:4.0.5-management
+    platform: linux/amd64
+    environment:
+      RABBITMQ_DEFAULT_USER: guest
+      RABBITMQ_DEFAULT_PASS: guest
+    networks:
+      dg:
+        aliases: [rabbitmq]
+    restart: unless-stopped
+
+  grok_pipe:
+    image: datagrok/grok_pipe:latest
+    platform: linux/amd64
+    environment:
+      API_KEY: test-key
+    networks:
+      dg:
+        aliases: [grok_pipe]
+    restart: unless-stopped
+
+  datagrok:
+    image: datagrok/datagrok:\${DATAGROK_VERSION:-latest}
+    depends_on:
+      postgres:
+        condition: service_healthy
+      rabbitmq:
+        condition: service_started
+    environment:
+      GROK_PARAMETERS: |
+        {
+          "dbServer": "database",
+          "db": "datagrok",
+          "dbLogin": "dg",
+          "dbPassword": "dg",
+          "dbAdminLogin": "postgres",
+          "dbAdminPassword": "postgres",
+          "adminPassword": "admin",
+          "adminDevKey": "admin",
+          "webRoot": "http://datagrok:8080",
+          "apiRoot": "http://datagrok:8080/api",
+          "deployDemo": true,
+          "deployTestDemo": false
+        }
+    ports:
+      - "\${DG_PORT:-0}:8080"
+    volumes:
+      - datagrok_data:/home/grok/data
+      - datagrok_cfg:/home/grok/cfg
+    networks:
+      dg:
+        aliases: [datagrok]
+    restart: on-failure
+
+  # ── Optional services (use --profile to enable) ──────────────
+
+  grok_connect:
+    image: datagrok/grok_connect:\${GROK_CONNECT_VERSION:-latest}
+    platform: linux/amd64
+    environment:
+      GROK_CONNECT_PORT: 1234
+    networks:
+      dg:
+        aliases: [grok_connect]
+    restart: unless-stopped
+
+  grok_spawner:
+    image: datagrok/grok_spawner:\${GROK_SPAWNER_VERSION:-latest}
+    platform: linux/amd64
+    user: root
+    environment:
+      X_API_KEY: test-x-api-key
+      GROK_SPAWNER_ENVIRONMENT: \${COMPOSE_PROJECT_NAME:-dg-pkg}
+      GROK_SPAWNER_CORE_MODE: "false"
+      GROK_SPAWNER_FORCE_DOCKER_TYPE_HOST: "true"
+    volumes:
+      - /var/run/docker.sock:/var/run/docker.sock
+    networks:
+      dg:
+        aliases: [grok_spawner]
+    restart: unless-stopped
+    profiles: ["full"]
+
+  jupyter_kernel_gateway:
+    image: datagrok/jupyter_kernel_gateway:\${JKG_VERSION:-latest}
+    platform: linux/amd64
+    depends_on:
+      rabbitmq:
+        condition: service_started
+    environment:
+      GROK_PARAMETERS: |
+        {
+          "queueSettings": {
+            "useQueue": true,
+            "amqpHost": "rabbitmq",
+            "amqpUser": "guest",
+            "amqpPassword": "guest",
+            "amqpPort": 5672,
+            "pipeHost": "grok_pipe",
+            "pipePort": 3000,
+            "pipeKey": "test-key",
+            "maxConcurrentCalls": 16
+          }
+        }
+    networks:
+      dg:
+        aliases: [jupyter_kernel_gateway]
+    restart: unless-stopped
+    profiles: ["scripting", "full"]
+
+  world:
+    image: datagrok/demo_db_postgres:12-1.1.0
+    environment:
+      POSTGRES_DB: world
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: postgres
+    volumes:
+      - demo_world:/var/lib/postgresql/data
+    networks:
+      dg:
+        aliases: [world]
+    restart: on-failure
+    profiles: ["demo", "full"]
+
+  test_db:
+    image: datagrok/demo_db_postgres:12-1.1.0
+    environment:
+      POSTGRES_DB: test
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: postgres
+    volumes:
+      - demo_test:/var/lib/postgresql/data
+    networks:
+      dg:
+        aliases: [test_db]
+    restart: on-failure
+    profiles: ["demo", "full"]
+
+  northwind:
+    image: datagrok/demo_db_postgres:12-1.1.0
+    environment:
+      POSTGRES_DB: northwind
+      POSTGRES_USER: postgres
+      POSTGRES_PASSWORD: postgres
+    volumes:
+      - demo_northwind:/var/lib/postgresql/data
+    networks:
+      dg:
+        aliases: [northwind]
+    restart: on-failure
+    profiles: ["demo", "full"]
+
+  # ── Tools dev container (pre-built image) ────────────────────
+
+  tools-dev:
+    image: datagrok/tools-dev:\${TOOLS_DEV_VERSION:-latest}
+    cap_add:
+      - SYS_ADMIN
+    security_opt:
+      - seccomp=unconfined
+    volumes:
+      - \${WORKTREE_PATH:-.}:/workspace/repo
+      - \${DOCKER_SOCK}:/var/run/docker.sock
+      - npm_cache:/home/node/.npm
+    environment:
+      ANTHROPIC_API_KEY: \${ANTHROPIC_API_KEY:-}
+      DG_VERSION: \${DG_VERSION:-latest}
+      DG_PUBLIC_REPO: \${DG_PUBLIC_REPO:-https://github.com/datagrok-ai/public.git}
+      DG_PUBLIC_BRANCH: \${DG_PUBLIC_BRANCH:-}
+      JIRA_URL: \${JIRA_URL:-https://reddata.atlassian.net}
+      JIRA_USERNAME: \${JIRA_USERNAME:-}
+      JIRA_TOKEN: \${JIRA_TOKEN:-}
+      GITHUB_TOKEN: \${GITHUB_TOKEN:-}
+      TASK_KEY: \${TASK_KEY:-}
+    working_dir: /workspace/repo
+    networks:
+      dg:
+        aliases: [tools-dev]
+    stdin_open: true
+    tty: true
+    restart: unless-stopped
+
+volumes:
+  pgdata:
+  datagrok_data:
+  datagrok_cfg:
+  demo_world:
+  demo_test:
+  demo_northwind:
+  npm_cache:
+
+networks:
+  dg:
+    name: dg-pkg-\${TASK_KEY:-default}-net
+`;
+function findGitRoot(startDir) {
+  let current = startDir;
+  while (true) {
+    if (_fs.default.existsSync(_path.default.join(current, '.git'))) return current;
+    const parent = _path.default.dirname(current);
+    if (parent === current) return undefined;
+    current = parent;
+  }
+}
+
+/** Check if the repo root is the public Datagrok repo (has js-api/ at root). */
+function isPublicRepo(repoRoot) {
+  return _fs.default.existsSync(_path.default.join(repoRoot, 'js-api')) || _fs.default.existsSync(_path.default.join(repoRoot, 'public', 'js-api'));
+}
+
+/**
+ * Resolve the Datagrok version to use:
+ * - Explicit --version flag takes priority
+ * - Public repo: bleeding-edge (tracks development)
+ * - Otherwise: latest
+ */
+function resolveDatagrokVersion(args, repoRoot) {
+  if (args.version) return args.version;
+  if (repoRoot && isPublicRepo(repoRoot)) {
+    color.info('Public repo detected — using bleeding-edge for datagrok');
+    return 'bleeding-edge';
+  }
+  return 'latest';
+}
+function getProjectDir(taskKey) {
+  return _path.default.join(_os.default.tmpdir(), `dg-pkg-${taskKey}`);
+}
+
+/** Find a free TCP port by binding to port 0 and reading the assigned port. */
+function findFreePort() {
+  return new Promise((resolve, reject) => {
+    const srv = _net.default.createServer();
+    srv.listen(0, '127.0.0.1', () => {
+      const addr = srv.address();
+      const port = typeof addr === 'object' && addr ? addr.port : 0;
+      srv.close(() => resolve(port));
+    });
+    srv.on('error', reject);
+  });
+}
+function writeProjectFiles(taskKey, args, worktreeRoot, dgPort) {
+  const projectDir = getProjectDir(taskKey);
+  if (!_fs.default.existsSync(projectDir)) _fs.default.mkdirSync(projectDir, {
+    recursive: true
+  });
+
+  // Write the embedded compose template
+  _fs.default.writeFileSync(_path.default.join(projectDir, 'docker-compose.yaml'), COMPOSE_TEMPLATE);
+
+  // Resolve Docker socket path
+  const dockerSock = process.platform === 'win32' ? '//var/run/docker.sock' : '/var/run/docker.sock';
+
+  // Generate .env — all paths use forward slashes for Docker compatibility
+  const envLines = [`WORKTREE_PATH=${toDockerPath(worktreeRoot)}`, `DG_PORT=${dgPort}`, `TASK_KEY=${taskKey.toLowerCase()}`, `DOCKER_SOCK=${dockerSock}`, `DATAGROK_VERSION=${args.version || 'latest'}`, `DG_VERSION=${args.version || 'latest'}`, `GROK_CONNECT_VERSION=${args['grok-connect-version'] || 'latest'}`, `GROK_SPAWNER_VERSION=${args['grok-spawner-version'] || 'latest'}`, `JKG_VERSION=${args['jkg-version'] || 'latest'}`, `TOOLS_DEV_VERSION=${args['tools-dev-version'] || 'latest'}`];
+  for (const env of ['ANTHROPIC_API_KEY', 'DG_PUBLIC_BRANCH', 'JIRA_URL', 'JIRA_USERNAME', 'JIRA_TOKEN', 'GITHUB_TOKEN']) if (process.env[env]) envLines.push(`${env}=${process.env[env]}`);
+  _fs.default.writeFileSync(_path.default.join(projectDir, '.env'), envLines.join('\n') + '\n');
+
+  // Write host config compose override (mirrors deploy/fat_dev/dg-claude approach)
+  const volumes = [];
+
+  // Claude profile (~/.claude + ~/.claude.json)
+  const claudeHome = findClaudeHome();
+  if (claudeHome) {
+    volumes.push(`      - "${toDockerPath(claudeHome)}:/home/node/.claude"`);
+    const claudeState = _path.default.join(_path.default.dirname(claudeHome), '.claude.json');
+    if (_fs.default.existsSync(claudeState) && _fs.default.statSync(claudeState).isFile()) volumes.push(`      - "${toDockerPath(claudeState)}:/home/node/.claude.json"`);
+    color.info(`Claude profile: ${claudeHome}`);
+  } else color.warn('No Claude profile found. Set CLAUDE_HOME or run "claude" locally to log in.');
+  const overridePath = _path.default.join(projectDir, 'docker-compose.override.yaml');
+  if (volumes.length > 0) {
+    const override = ['services:', '  tools-dev:', '    volumes:', ...volumes].join('\n') + '\n';
+    _fs.default.writeFileSync(overridePath, override);
+  } else if (_fs.default.existsSync(overridePath)) _fs.default.unlinkSync(overridePath);
+  return projectDir;
+}
+function runCompose(projectDir, taskKey, args, ...composeArgs) {
+  // Use --project-directory so compose picks up .env automatically
+  const cmdArgs = ['compose', '--project-directory', projectDir, '-p', `dg-pkg-${taskKey.toLowerCase()}`];
+  // Include host config override if present (Claude profile, grok config)
+  const overrideFile = _path.default.join(projectDir, 'docker-compose.override.yaml');
+  if (_fs.default.existsSync(overrideFile)) cmdArgs.push('-f', _path.default.join(projectDir, 'docker-compose.yaml'), '-f', overrideFile);
+  if (args.profile) cmdArgs.push('--profile', args.profile);
+  cmdArgs.push(...composeArgs);
+  const result = (0, _child_process.spawnSync)('docker', cmdArgs, {
+    stdio: 'inherit'
+  });
+  return result.status ?? 1;
+}
+
+/** Check if Datagrok responds with 200 at /api/info/server. */
+function httpProbe(port) {
+  return new Promise(resolve => {
+    const req = _http.default.get(`http://localhost:${port}/api/info/server`, {
+      timeout: 5000
+    }, res => {
+      res.resume();
+      resolve(res.statusCode === 200);
+    });
+    req.on('error', () => resolve(false));
+    req.on('timeout', () => {
+      req.destroy();
+      resolve(false);
+    });
+  });
+}
+async function waitForDatagrok(port, timeoutMs = 180000) {
+  const url = `http://localhost:${port}`;
+  const start = Date.now();
+  color.info(`Waiting for Datagrok at ${url}...`);
+  while (Date.now() - start < timeoutMs) {
+    if (await httpProbe(port)) {
+      color.info('Datagrok is ready.');
+      return true;
+    }
+    await new Promise(resolve => setTimeout(resolve, 3000));
+  }
+  color.error(`Datagrok did not become healthy within ${timeoutMs / 1000}s`);
+  return false;
+}
+function destroyProject(taskKey, args, repoRoot) {
+  const projectDir = getProjectDir(taskKey);
+  if (!_fs.default.existsSync(_path.default.join(projectDir, 'docker-compose.yaml'))) {
+    color.error(`No compose project found for "${taskKey}" in ${projectDir}`);
+    return false;
+  }
+  color.info(`Destroying "${taskKey}"...`);
+  runCompose(projectDir, taskKey, args, 'down', '-v');
+
+  // Remove worktree
+  const worktreePath = _path.default.join(_os.default.homedir(), 'pkg-worktrees', taskKey);
+  if (_fs.default.existsSync(worktreePath) && repoRoot) {
+    (0, _child_process.spawnSync)('git', ['worktree', 'remove', worktreePath, '--force'], {
+      cwd: repoRoot,
+      stdio: 'inherit'
+    });
+    (0, _child_process.spawnSync)('git', ['branch', '-D', taskKey], {
+      cwd: repoRoot,
+      stdio: 'inherit'
+    });
+  }
+
+  // Clean up project dir
+  _fs.default.rmSync(projectDir, {
+    recursive: true,
+    force: true
+  });
+  color.info(`Destroyed "${taskKey}".`);
+  return true;
+}
+
+/** List all project keys that have a compose file in the temp dir. */
+function listProjects() {
+  const prefix = 'dg-pkg-';
+  const tmpDir = _os.default.tmpdir();
+  const keys = [];
+  for (const entry of _fs.default.readdirSync(tmpDir)) {
+    if (entry.startsWith(prefix) && _fs.default.existsSync(_path.default.join(tmpDir, entry, 'docker-compose.yaml'))) keys.push(entry.slice(prefix.length));
+  }
+  return keys;
+}
+async function claude(args) {
+  const subcommand = args._[1];
+  const taskKey = subcommand === 'destroy' ? args._[2] : subcommand;
+
+  // Handle destroy: bring down containers, remove worktree, clean up
+  if (subcommand === 'destroy') {
+    if (!taskKey) {
+      color.error('Usage: grok claude destroy <project>');
+      return false;
+    }
+    const repoRoot = findGitRoot(process.cwd());
+    return destroyProject(taskKey, args, repoRoot);
+  }
+
+  // Handle destroy-all: destroy all known projects
+  if (subcommand === 'destroy-all') {
+    const projects = listProjects();
+    if (projects.length === 0) {
+      color.info('No projects found.');
+      return true;
+    }
+    const repoRoot = findGitRoot(process.cwd());
+    for (const key of projects) destroyProject(key, args, repoRoot);
+    return true;
+  }
+
+  // Require project name
+  if (!taskKey) return false;
+
+  // Reject master/main as task key
+  if (taskKey === 'master' || taskKey === 'main') {
+    color.error(`Cannot use '${taskKey}' as project name — always work on a dedicated branch.`);
+    return false;
+  }
+
+  // Find repo root (optional — not required for --in-place or non-git directories)
+  const repoRoot = findGitRoot(process.cwd());
+  const inPlace = args['in-place'] || !repoRoot;
+  if (!repoRoot && !args['in-place']) color.warn('Not inside a git repository — running in-place (no worktree).');
+
+  // Resolve Datagrok version (only datagrok image uses this; others default to latest)
+  if (!args.version) {
+    args.version = resolveDatagrokVersion(args, repoRoot);
+    color.info(`Datagrok version: ${args.version}`);
+  }
+
+  // When inside a public repo, tell the container which branch to clone (avoids slow version resolution)
+  if (repoRoot && isPublicRepo(repoRoot) && !process.env.DG_PUBLIC_BRANCH) {
+    const branchResult = (0, _child_process.spawnSync)('git', ['rev-parse', '--abbrev-ref', 'HEAD'], {
+      cwd: repoRoot
+    });
+    const branch = branchResult.stdout?.toString().trim();
+    if (branch) process.env.DG_PUBLIC_BRANCH = branch;
+  }
+
+  // Determine workspace root: worktree or current directory
+  let worktreeRoot;
+  if (inPlace) {
+    worktreeRoot = process.cwd();
+    color.info(`Working in-place: ${worktreeRoot}`);
+  } else {
+    const worktreesDir = _path.default.join(_os.default.homedir(), 'pkg-worktrees');
+    const worktreePath = _path.default.join(worktreesDir, taskKey);
+    if (!_fs.default.existsSync(worktreePath)) {
+      _fs.default.mkdirSync(worktreesDir, {
+        recursive: true
+      });
+      const result = (0, _child_process.spawnSync)('git', ['worktree', 'add', worktreePath, '-b', taskKey], {
+        cwd: repoRoot,
+        stdio: 'inherit'
+      });
+      if (result.status !== 0) {
+        color.error('Failed to create git worktree.');
+        return false;
+      }
+      color.info(`Created worktree: ${worktreePath}`);
+    } else color.info(`Worktree already exists at ${worktreePath}`);
+    worktreeRoot = worktreePath;
+  }
+
+  // Warn about missing optional environment variables
+  const optionalVars = ['JIRA_URL', 'JIRA_USERNAME', 'JIRA_TOKEN', 'GITHUB_TOKEN'];
+  const missing = optionalVars.filter(v => !process.env[v]);
+  if (missing.length > 0) color.warn(`Not set: ${missing.join(', ')}`);
+
+  // Find a free port for Datagrok (stable across container restarts)
+  const dgPort = args.port || (await findFreePort());
+  color.info(`Datagrok UI will be at: http://localhost:${dgPort}`);
+
+  // Write compose + .env to temp dir (no external file dependencies)
+  const projectDir = writeProjectFiles(taskKey, args, worktreeRoot, dgPort);
+  color.info(`Workspace: ${worktreeRoot}`);
+
+  // Start containers
+  color.info('Starting containers...');
+  const upStatus = runCompose(projectDir, taskKey, args, 'up', '-d', '--wait');
+  if (upStatus !== 0) {
+    color.error('Failed to start containers.');
+    return false;
+  }
+
+  // Wait for Datagrok to be healthy
+  const healthy = await waitForDatagrok(dgPort);
+  if (!healthy) color.warn('Datagrok may not be ready. Proceeding anyway...');
+
+  // Determine whether this is a public repo and compute Claude working directory
+  const isPublic = repoRoot ? isPublicRepo(repoRoot) : false;
+  const claudeWorkDir = isPublic ? '/workspace/repo/public' : `/workspace/public/packages/${taskKey}`;
+
+  // Fix ownership on bind-mounted directories (host UID may differ from container node user)
+  const containerName = `dg-pkg-${taskKey.toLowerCase()}-tools-dev-1`;
+  (0, _child_process.spawnSync)('docker', ['exec', '-u', 'root', containerName, 'bash', '-c', 'chown node:node /workspace 2>/dev/null; ' + 'for d in /home/node/.claude /home/node/.npm; do ' + 'mkdir -p "$d" 2>/dev/null; chown -R node:node "$d" 2>/dev/null; done; ' + '[ -f /home/node/.claude.json ] && chown node:node /home/node/.claude.json 2>/dev/null; true'], {
+    stdio: 'inherit'
+  });
+
+  // Copy host grok config into container and ensure 'local' server exists
+  (0, _child_process.spawnSync)('docker', ['exec', '-u', 'root', containerName, 'bash', '-c', 'mkdir -p /home/node/.grok && chown node:node /home/node/.grok'], {
+    stdio: 'inherit'
+  });
+  const grokConfigPath = _path.default.join(_os.default.homedir(), '.grok', 'config.yaml');
+  if (_fs.default.existsSync(grokConfigPath)) {
+    (0, _child_process.spawnSync)('docker', ['cp', grokConfigPath, `${containerName}:/home/node/.grok/config.yaml`], {
+      stdio: 'inherit'
+    });
+    (0, _child_process.spawnSync)('docker', ['exec', '-u', 'root', containerName, 'chown', 'node:node', '/home/node/.grok/config.yaml'], {
+      stdio: 'inherit'
+    });
+    color.info('Copied grok config into container');
+  }
+
+  // Add/ensure 'local' server pointing to compose datagrok (key=admin matches GROK_PARAMETERS)
+  (0, _child_process.spawnSync)('docker', ['exec', containerName, 'node', '-e', `
+    const fs = require('fs');
+    const p = '/home/node/.grok/config.yaml';
+    let t = '';
+    try { t = fs.readFileSync(p, 'utf8'); } catch {}
+    if (!t.trim()) {
+      t = 'default: local\\nservers:\\n  local:\\n    url: http://datagrok:8080/api\\n    key: admin\\n';
+    } else if (!t.includes('datagrok:8080')) {
+      t = t.replace(/^(servers:)/m, '\\$1\\n  local:\\n    url: http://datagrok:8080/api\\n    key: admin');
+      t = t.replace(/^default:.*/m, 'default: local');
+    } else {
+      t = t.replace(/^default:.*/m, 'default: local');
+    }
+    fs.writeFileSync(p, t);
+  `], {
+    stdio: 'inherit'
+  });
+
+  // Set up workspace context: for non-public repos, bind-mount workspace into public/packages/
+  // so that process.cwd() returns the mount-point path (not the resolved symlink target)
+  // and relative paths like ../../js-api resolve correctly inside the public repo tree.
+  if (!isPublic) {
+    (0, _child_process.spawnSync)('docker', ['exec', '-u', 'root', containerName, 'bash', '-c', 'for i in $(seq 1 60); do [ -d /workspace/public/js-api ] && break; sleep 3; done; ' + 'if [ -d /workspace/public/js-api ]; then ' + '  mkdir -p /workspace/public/packages 2>/dev/null; ' + `  rm -f /workspace/public/packages/${taskKey} 2>/dev/null; ` + `  if ! mountpoint -q /workspace/public/packages/${taskKey} 2>/dev/null; then ` + `    mkdir -p /workspace/public/packages/${taskKey} && ` + `    mount --bind /workspace/repo /workspace/public/packages/${taskKey}; ` + '  fi; ' + `  echo "[grok claude] Workspace at /workspace/public/packages/${taskKey}"; ` + 'else ' + '  echo "[grok claude] Warning: public repo clone not ready"; ' + 'fi'], {
+      stdio: 'inherit'
+    });
+  }
+  const claudeArgs = ['--dangerously-skip-permissions'];
+  if (args.prompt) claudeArgs.push('-p', args.prompt);
+  color.info(`Launching Claude Code in container ${containerName}...`);
+  (0, _child_process.spawnSync)('docker', ['exec', '-it', '-w', claudeWorkDir, containerName, 'claude', ...claudeArgs], {
+    stdio: 'inherit'
+  });
+
+  // On exit, optionally stop containers
+  if (!args.keep) {
+    color.info('Stopping containers...');
+    runCompose(projectDir, taskKey, args, 'down');
+    color.info('Containers stopped.');
+  } else color.info(`Containers left running (--keep). Use "grok claude destroy ${taskKey}" to tear down.`);
+  return true;
+}

package/bin/commands/help.js

@@ -14,6 +14,7 @@ Commands:
     api       Create wrapper functions
     build     Build a package or multiple packages
     check     Check package content (function signatures, etc.)
+    claude    Launch Claude Code in a Datagrok dev container
     config    Create and manage config files
     create    Create a package
     init      Modify a package template
@@ -29,6 +30,44 @@ To get help on a particular command, use:
 Read more about the package development workflow:
 https://datagrok.ai/help/develop/develop
 `;
+const HELP_CLAUDE = `
+Usage: grok claude <project>              Start or reattach to a project
+       grok claude destroy <project>      Stop containers + remove worktree
+       grok claude destroy-all            Destroy all projects
+
+Launch Claude Code inside a Datagrok dev container. Creates a git worktree
+for the project, starts a full Datagrok stack (postgres, rabbitmq, grok_pipe,
+datagrok) and opens Claude Code in a tools-dev container.
+
+Version is auto-detected: bleeding-edge for the public repo,
+latest stable release (from Docker Hub) for other repos.
+
+Options:
+[--version <tag>] [--profile <name>] [--keep]
+[--port <N>] [--prompt <text>] [--in-place]
+[--grok-connect-version <tag>] [--grok-spawner-version <tag>]
+[--jkg-version <tag>] [--tools-dev-version <tag>]
+
+--version               Datagrok image version (default: bleeding-edge for public repo, latest otherwise)
+--profile               Compose profile: demo, scripting, full (default: none)
+--keep                  Don't stop containers on exit
+--port                  Datagrok host port (default: random available)
+--prompt                Pass initial prompt to Claude Code (non-interactive)
+--in-place              Use current directory instead of creating a git worktree
+--grok-connect-version  grok_connect image version (default: latest)
+--grok-spawner-version  grok_spawner image version (default: latest)
+--jkg-version           jupyter_kernel_gateway image version (default: latest)
+--tools-dev-version     tools-dev image version (default: latest)
+
+Examples:
+  grok claude GROK-12345                        Start working on a task
+  grok claude GROK-12345 --version 1.22.0       Use specific Datagrok version
+  grok claude GROK-12345 --profile full --keep   Start all services, keep running
+  grok claude GROK-12345 --prompt "fix the bug"  One-shot command
+  grok claude GROK-12345 --in-place              Work in current directory
+  grok claude destroy GROK-12345                 Tear down a task
+  grok claude destroy-all                        Tear down everything
+`;
 const HELP_ADD = `
 Usage: grok add <entity> <name>
 
@@ -272,6 +311,7 @@ const help = exports.help = {
   api: HELP_API,
   build: HELP_BUILD,
   check: HELP_CHECK,
+  claude: HELP_CLAUDE,
   config: HELP_CONFIG,
   create: HELP_CREATE,
   init: HELP_INIT,