clawmini 0.0.1

package/src/shared/workspace.ts

@@ -0,0 +1,500 @@
+/* eslint-disable max-lines */
+import { execSync } from 'node:child_process';
+import fs from 'node:fs';
+import fsPromises from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import {
+  type Agent,
+  AgentSchema,
+  type ChatSettings,
+  ChatSettingsSchema,
+  type AgentSessionSettings,
+  AgentSessionSettingsSchema,
+  type Environment,
+  EnvironmentSchema,
+  type Settings,
+  SettingsSchema,
+} from './config.js';
+import { pathIsInsideDir } from './utils/fs.js';
+
+export function getWorkspaceRoot(startDir = process.cwd()): string {
+  let curr = startDir;
+  while (curr !== path.parse(curr).root) {
+    if (fs.existsSync(path.join(curr, '.clawmini'))) {
+      return curr;
+    }
+    if (fs.existsSync(path.join(curr, 'package.json')) || fs.existsSync(path.join(curr, '.git'))) {
+      return curr;
+    }
+    curr = path.dirname(curr);
+  }
+  return startDir;
+}
+
+export function resolveAgentWorkDir(
+  agentId: string,
+  customDir?: string,
+  startDir = process.cwd()
+): string {
+  const workspaceRoot = getWorkspaceRoot(startDir);
+  const dirPath = customDir
+    ? path.resolve(workspaceRoot, customDir)
+    : path.resolve(workspaceRoot, agentId);
+
+  if (!pathIsInsideDir(dirPath, workspaceRoot, { allowSameDir: true })) {
+    throw new Error('Invalid agent directory: resolves outside the workspace.');
+  }
+
+  return dirPath;
+}
+
+export async function ensureAgentWorkDir(
+  agentId: string,
+  customDir?: string,
+  startDir = process.cwd()
+): Promise<string> {
+  const dirPath = resolveAgentWorkDir(agentId, customDir, startDir);
+
+  if (!fs.existsSync(dirPath)) {
+    await fsPromises.mkdir(dirPath, { recursive: true });
+    console.log(`Created agent working directory at ${dirPath}`);
+  }
+  return dirPath;
+}
+
+export function getClawminiDir(startDir = process.cwd()): string {
+  return path.join(getWorkspaceRoot(startDir), '.clawmini');
+}
+
+export function getSocketPath(startDir = process.cwd()): string {
+  return path.join(getClawminiDir(startDir), 'server.sock');
+}
+
+export function getSettingsPath(startDir = process.cwd()): string {
+  return path.join(getClawminiDir(startDir), 'settings.json');
+}
+
+export function getPoliciesPath(startDir = process.cwd()): string {
+  return path.join(getClawminiDir(startDir), 'policies.json');
+}
+
+export function getChatSettingsPath(chatId: string, startDir = process.cwd()): string {
+  return path.join(getClawminiDir(startDir), 'chats', chatId, 'settings.json');
+}
+
+export function isValidAgentId(agentId: string): boolean {
+  if (!agentId || agentId.length === 0) return false;
+  return /^[a-zA-Z0-9_]+(?:-[a-zA-Z0-9_]+)*$/.test(agentId);
+}
+
+export function getAgentDir(agentId: string, startDir = process.cwd()): string {
+  if (!isValidAgentId(agentId)) {
+    throw new Error(`Invalid agent ID: ${agentId}`);
+  }
+  return path.join(getClawminiDir(startDir), 'agents', agentId);
+}
+
+export function getAgentSettingsPath(agentId: string, startDir = process.cwd()): string {
+  return path.join(getAgentDir(agentId, startDir), 'settings.json');
+}
+
+export function getAgentSessionSettingsPath(
+  agentId: string,
+  sessionId: string,
+  startDir = process.cwd()
+): string {
+  if (!isValidAgentId(agentId)) {
+    throw new Error(`Invalid agent ID: ${agentId}`);
+  }
+  return path.join(
+    getClawminiDir(startDir),
+    'agents',
+    agentId,
+    'sessions',
+    sessionId,
+    'settings.json'
+  );
+}
+
+async function readJsonFile(filePath: string): Promise<Record<string, unknown> | null> {
+  try {
+    const data = await fsPromises.readFile(filePath, 'utf-8');
+    return JSON.parse(data) as Record<string, unknown>;
+  } catch {
+    return null;
+  }
+}
+
+async function writeJsonFile(filePath: string, data: Record<string, unknown>): Promise<void> {
+  const dir = path.dirname(filePath);
+  await fsPromises.mkdir(dir, { recursive: true });
+  await fsPromises.writeFile(filePath, JSON.stringify(data, null, 2), 'utf-8');
+}
+
+export async function readChatSettings(
+  chatId: string,
+  startDir = process.cwd()
+): Promise<ChatSettings | null> {
+  const data = await readJsonFile(getChatSettingsPath(chatId, startDir));
+  if (!data) return null;
+  const parsed = ChatSettingsSchema.safeParse(data);
+  return parsed.success ? parsed.data : null;
+}
+
+export async function writeChatSettings(
+  chatId: string,
+  data: ChatSettings,
+  startDir = process.cwd()
+): Promise<void> {
+  await writeJsonFile(getChatSettingsPath(chatId, startDir), data as Record<string, unknown>);
+}
+
+export async function readAgentSessionSettings(
+  agentId: string,
+  sessionId: string,
+  startDir = process.cwd()
+): Promise<AgentSessionSettings | null> {
+  const data = await readJsonFile(getAgentSessionSettingsPath(agentId, sessionId, startDir));
+  if (!data) return null;
+  const parsed = AgentSessionSettingsSchema.safeParse(data);
+  return parsed.success ? parsed.data : null;
+}
+
+export async function writeAgentSessionSettings(
+  agentId: string,
+  sessionId: string,
+  data: AgentSessionSettings,
+  startDir = process.cwd()
+): Promise<void> {
+  await writeJsonFile(
+    getAgentSessionSettingsPath(agentId, sessionId, startDir),
+    data as Record<string, unknown>
+  );
+}
+
+export async function getAgent(agentId: string, startDir = process.cwd()): Promise<Agent | null> {
+  const filePath = getAgentSettingsPath(agentId, startDir);
+  let dataStr: string;
+  try {
+    dataStr = await fsPromises.readFile(filePath, 'utf-8');
+  } catch (err: unknown) {
+    if (err && typeof err === 'object' && 'code' in err && err.code === 'ENOENT') return null;
+    throw err;
+  }
+
+  let data: unknown;
+  try {
+    data = JSON.parse(dataStr);
+  } catch (parseErr: unknown) {
+    const message = parseErr instanceof Error ? parseErr.message : String(parseErr);
+    throw new Error(`Invalid JSON in ${filePath}: ${message}`, { cause: parseErr });
+  }
+
+  const parsed = AgentSchema.safeParse(data);
+  if (!parsed.success) {
+    throw new Error(`Invalid schema in ${filePath}: ${parsed.error.message}`);
+  }
+  return parsed.data;
+}
+
+export async function writeAgentSettings(
+  agentId: string,
+  data: Agent,
+  startDir = process.cwd()
+): Promise<void> {
+  await ensureAgentWorkDir(agentId, data.directory, startDir);
+  await writeJsonFile(getAgentSettingsPath(agentId, startDir), data as Record<string, unknown>);
+}
+
+export async function listAgents(startDir = process.cwd()): Promise<string[]> {
+  const agentsDir = path.join(getClawminiDir(startDir), 'agents');
+  try {
+    const entries = await fsPromises.readdir(agentsDir, { withFileTypes: true });
+    const agentIds = [];
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const settingsPath = path.join(agentsDir, entry.name, 'settings.json');
+        try {
+          await fsPromises.access(settingsPath);
+          agentIds.push(entry.name);
+        } catch {
+          // No settings.json, probably just a sessions dir for a non-existent agent or default agent
+        }
+      }
+    }
+    return agentIds;
+  } catch {
+    return [];
+  }
+}
+
+export async function deleteAgent(agentId: string, startDir = process.cwd()): Promise<void> {
+  const dir = getAgentDir(agentId, startDir);
+  const agentsDir = path.join(getClawminiDir(startDir), 'agents');
+
+  if (!pathIsInsideDir(dir, agentsDir)) {
+    throw new Error(`Security Error: Cannot delete agent directory outside of ${agentsDir}`);
+  }
+
+  try {
+    await fsPromises.rm(dir, { recursive: true, force: true });
+  } catch {
+    // Ignore if not found
+  }
+}
+
+async function isDirectory(dirPath: string): Promise<boolean> {
+  try {
+    const stat = await fsPromises.stat(dirPath);
+    return stat.isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+export async function resolveTemplatePathBase(
+  templateName: string,
+  startDir = process.cwd()
+): Promise<string> {
+  const workspaceRoot = getWorkspaceRoot(startDir);
+  const localTemplatePath = path.join(workspaceRoot, '.clawmini', 'templates', templateName);
+
+  if (await isDirectory(localTemplatePath)) {
+    return localTemplatePath;
+  }
+
+  // Fallback to built-in templates
+  // Find the clawmini package root by looking for package.json
+  let currentDir = path.dirname(fileURLToPath(import.meta.url));
+  while (
+    currentDir !== path.parse(currentDir).root &&
+    !fs.existsSync(path.join(currentDir, 'package.json'))
+  ) {
+    currentDir = path.dirname(currentDir);
+  }
+
+  const searchPath = path.join(currentDir, 'templates', templateName);
+
+  if (await isDirectory(searchPath)) {
+    return searchPath;
+  }
+
+  throw new Error(
+    `Template not found: ${templateName} (searched local: ${localTemplatePath}, built-in: ${searchPath})`
+  );
+}
+
+export async function resolveTemplatePath(
+  templateName: string,
+  startDir = process.cwd()
+): Promise<string> {
+  if (templateName === 'environments' || templateName.startsWith('environments/')) {
+    throw new Error(`Template not found: ${templateName}`);
+  }
+  return resolveTemplatePathBase(templateName, startDir);
+}
+
+export async function resolveEnvironmentTemplatePath(
+  templateName: string,
+  startDir = process.cwd()
+): Promise<string> {
+  return resolveTemplatePathBase(path.join('environments', templateName), startDir);
+}
+
+export async function copyTemplateBase(
+  templatePath: string,
+  targetDir: string,
+  allowMissingDir: boolean = false
+): Promise<void> {
+  // Check if target directory exists and is not empty
+  try {
+    const entries = await fsPromises.readdir(targetDir);
+    if (entries.length > 0) {
+      throw new Error(`Target directory is not empty: ${targetDir}`);
+    }
+  } catch (err: unknown) {
+    if (err && typeof err === 'object' && 'code' in err && err.code === 'ENOENT') {
+      if (allowMissingDir) {
+        await fsPromises.mkdir(targetDir, { recursive: true });
+      } else {
+        throw new Error(`Target directory does not exist: ${targetDir}`, { cause: err });
+      }
+    } else {
+      throw err;
+    }
+  }
+
+  // Recursively copy
+  await fsPromises.cp(templatePath, targetDir, { recursive: true });
+}
+
+export async function copyTemplate(
+  templateName: string,
+  targetDir: string,
+  startDir = process.cwd()
+): Promise<void> {
+  const templatePath = await resolveTemplatePath(templateName, startDir);
+  await copyTemplateBase(templatePath, targetDir, false);
+}
+
+export async function copyEnvironmentTemplate(
+  templateName: string,
+  targetDir: string,
+  startDir = process.cwd()
+): Promise<void> {
+  const templatePath = await resolveEnvironmentTemplatePath(templateName, startDir);
+  await copyTemplateBase(templatePath, targetDir, true);
+}
+
+export async function applyTemplateToAgent(
+  agentId: string,
+  templateName: string,
+  overrides: Agent,
+  startDir = process.cwd()
+): Promise<void> {
+  const agentWorkDir = resolveAgentWorkDir(agentId, overrides.directory, startDir);
+  await copyTemplate(templateName, agentWorkDir, startDir);
+
+  const settingsPath = path.join(agentWorkDir, 'settings.json');
+  try {
+    const rawSettings = await fsPromises.readFile(settingsPath, 'utf-8');
+    const parsedSettings = JSON.parse(rawSettings);
+    const validation = AgentSchema.safeParse(parsedSettings);
+
+    if (validation.success) {
+      const templateData = validation.data;
+      if (templateData.directory) {
+        console.warn(
+          `Warning: Ignoring 'directory' field from template settings.json. Using default or provided directory.`
+        );
+        delete templateData.directory;
+      }
+
+      // Merge: overrides take precedence over templateData
+      const mergedEnv = { ...(templateData.env || {}), ...(overrides.env || {}) };
+      const mergedData: Agent = { ...templateData, ...overrides };
+      if (Object.keys(mergedEnv).length > 0) {
+        mergedData.env = mergedEnv;
+      }
+
+      await writeAgentSettings(agentId, mergedData, startDir);
+    }
+  } catch {
+    // Ignore parsing or file not found errors
+  } finally {
+    try {
+      await fsPromises.rm(settingsPath);
+    } catch {
+      // Ignore if it doesn't exist
+    }
+  }
+}
+
+export async function readSettings(startDir = process.cwd()): Promise<Settings | null> {
+  const data = await readJsonFile(getSettingsPath(startDir));
+  if (!data) return null;
+  const parsed = SettingsSchema.safeParse(data);
+  return parsed.success ? parsed.data : null;
+}
+
+export async function writeSettings(data: Settings, startDir = process.cwd()): Promise<void> {
+  await writeJsonFile(getSettingsPath(startDir), data as Record<string, unknown>);
+}
+
+export async function readPolicies(
+  startDir = process.cwd()
+): Promise<import('./policies.js').PolicyConfig | null> {
+  const data = await readJsonFile(getPoliciesPath(startDir));
+  if (!data) return null;
+  // Basic validation, assuming PolicyConfig structure
+  if (data.policies && typeof data.policies === 'object') {
+    return data as unknown as import('./policies.js').PolicyConfig;
+  }
+  return null;
+}
+
+export function getEnvironmentPath(name: string, startDir = process.cwd()): string {
+  return path.join(getClawminiDir(startDir), 'environments', name);
+}
+
+export async function readEnvironment(
+  name: string,
+  startDir = process.cwd()
+): Promise<Environment | null> {
+  const data = await readJsonFile(path.join(getEnvironmentPath(name, startDir), 'env.json'));
+  if (!data) return null;
+  const parsed = EnvironmentSchema.safeParse(data);
+  return parsed.success ? parsed.data : null;
+}
+
+export async function getActiveEnvironmentInfo(
+  targetPath: string,
+  startDir = process.cwd()
+): Promise<{ name: string; targetPath: string } | null> {
+  const settings = await readSettings(startDir);
+  if (!settings?.environments) return null;
+
+  const workspaceRoot = getWorkspaceRoot(startDir);
+  const resolvedTarget = path.resolve(workspaceRoot, targetPath);
+
+  let bestMatch: { name: string; targetPath: string } | null = null;
+  let maxDepth = -1;
+
+  for (const [envPath, envName] of Object.entries(settings.environments)) {
+    const resolvedEnvPath = path.resolve(workspaceRoot, envPath);
+
+    if (pathIsInsideDir(resolvedTarget, resolvedEnvPath, { allowSameDir: true })) {
+      const depth = resolvedEnvPath.split(path.sep).length;
+      if (depth > maxDepth) {
+        maxDepth = depth;
+        bestMatch = { name: envName, targetPath: resolvedEnvPath };
+      }
+    }
+  }
+
+  return bestMatch;
+}
+
+export async function getActiveEnvironmentName(
+  targetPath: string,
+  startDir = process.cwd()
+): Promise<string | null> {
+  const info = await getActiveEnvironmentInfo(targetPath, startDir);
+  return info ? info.name : null;
+}
+
+export async function enableEnvironment(
+  name: string,
+  targetPath: string = './',
+  startDir = process.cwd()
+): Promise<void> {
+  const targetDir = getEnvironmentPath(name, startDir);
+
+  // Copy template to targetDir if it does not already exist
+  if (!fs.existsSync(targetDir)) {
+    await copyEnvironmentTemplate(name, targetDir, startDir);
+    console.log(`Copied environment template '${name}'.`);
+  } else {
+    console.log(`Environment template '${name}' already exists in workspace.`);
+  }
+
+  const settings = (await readSettings(startDir)) || { chats: { defaultId: '' } };
+  const environments = settings.environments || {};
+
+  environments[targetPath] = name;
+  settings.environments = environments;
+
+  await writeSettings(settings, startDir);
+  console.log(`Enabled environment '${name}' for path '${targetPath}'.`);
+
+  // Execute init command if present
+  const envConfig = await readEnvironment(name, startDir);
+  if (envConfig?.init) {
+    // Get the target directory for the environment
+    const workspaceRoot = getWorkspaceRoot(startDir);
+    const affectedDir = path.resolve(workspaceRoot, targetPath);
+    console.log(`Executing init command for environment '${name}': ${envConfig.init}`);
+    execSync(envConfig.init, { cwd: affectedDir, stdio: 'inherit' });
+  }
+}

package/templates/environments/cladding/env.json

@@ -0,0 +1,7 @@
+{
+  "init": "cladding init",
+  "up": "cladding up",
+  "down": "cladding down",
+  "prefix": "cladding run {ENV_ARGS}",
+  "envFormat": "--env {key}"
+}

package/templates/environments/macos/env.json

@@ -0,0 +1,8 @@
+{
+  "prefix": "sandbox-exec -D WORKSPACE='{WORKSPACE_DIR}' -D AGENT='{AGENT_DIR}' -D HOME='{HOME_DIR}' -f '{ENV_DIR}/sandbox.sb' sh -c '{COMMAND}'",
+  "envFormat": "",
+  "env": {
+    "PATH": "{PATH}:{WORKSPACE_DIR}/bin"
+  },
+  "exportLiteTo": ".local/bin/clawmini-lite.js"
+}

package/templates/environments/macos/sandbox.sb

@@ -0,0 +1,21 @@
+(version 1)
+
+;; allow everything by default
+(allow default)
+
+;; deny all writes EXCEPT under specific paths
+(deny file-write*)
+(allow file-write*
+    (subpath (param "WORKSPACE"))
+    (subpath (string-append (param "HOME") "/.gemini"))
+    (subpath (string-append (param "HOME") "/.npm"))
+    (subpath (string-append (param "HOME") "/.cache"))
+    (subpath (string-append (param "HOME") "/.gitconfig"))
+    (subpath "/var")
+    (subpath "/private/var")
+    (literal "/dev/stdout")
+    (literal "/dev/stderr")
+    (literal "/dev/null")
+    (literal "/dev/ptmx")
+    (regex #"^/dev/ttys[0-9]*$")
+)

package/templates/environments/macos-proxy/allowlist.txt

@@ -0,0 +1 @@
+generativelanguage.googleapis.com

package/templates/environments/macos-proxy/env.json

@@ -0,0 +1,14 @@
+{
+  "up": "node \"$ENV_DIR/proxy.mjs\" > \"$ENV_DIR/proxy.log\" 2>&1 & echo $! > \"$ENV_DIR/proxy.pid\"",
+  "down": "if [ -f \"$ENV_DIR/proxy.pid\" ]; then kill $(cat \"$ENV_DIR/proxy.pid\") || true; rm -f \"$ENV_DIR/proxy.pid\"; fi",
+  "prefix": "sandbox-exec -D WORKSPACE='{WORKSPACE_DIR}' -D AGENT='{AGENT_DIR}' -D HOME='{HOME_DIR}' -f '{ENV_DIR}/sandbox.sb' sh -c '{COMMAND}'",
+  "envFormat": "",
+  "env": {
+    "HTTP_PROXY": "http://127.0.0.1:8888",
+    "http_proxy": "http://127.0.0.1:8888",
+    "HTTPS_PROXY": "http://127.0.0.1:8888",
+    "https_proxy": "http://127.0.0.1:8888",
+    "PATH": "{PATH}:{WORKSPACE_DIR}/bin"
+  },
+  "exportLiteTo": ".local/bin/clawmini-lite.js"
+}

package/templates/environments/macos-proxy/proxy.mjs

@@ -0,0 +1,86 @@
+import http from 'http';
+import net from 'net';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+// eslint-disable-next-line no-undef
+const envDir = process.env.ENV_DIR || __dirname;
+const allowlistPath = path.join(envDir, 'allowlist.txt');
+
+function isAllowed(hostname) {
+  try {
+    if (!fs.existsSync(allowlistPath)) {
+      return hostname === 'generativelanguage.googleapis.com';
+    }
+    const content = fs.readFileSync(allowlistPath, 'utf8');
+    const allowedDomains = content.split('\n')
+      .map(line => line.trim())
+      .filter(line => line.length > 0 && !line.startsWith('#'));
+    
+    return allowedDomains.some(domain => 
+      hostname === domain || hostname.endsWith(`.${domain}`)
+    );
+  } catch (err) {
+    console.error('Error reading allowlist:', err);
+    return false;
+  }
+}
+
+const server = http.createServer((req, res) => {
+  try {
+    const url = new URL(req.url);
+    if (!isAllowed(url.hostname)) {
+      console.log(`[HTTP] Blocked: ${url.hostname}`);
+      res.writeHead(403);
+      res.end('Domain not allowed by proxy allowlist\n');
+      return;
+    }
+    console.log(`[HTTP] Allowed: ${url.hostname}`);
+    
+    const proxyReq = http.request(url, {
+      method: req.method,
+      headers: req.headers,
+    }, (proxyRes) => {
+      res.writeHead(proxyRes.statusCode, proxyRes.headers);
+      proxyRes.pipe(res, { end: true });
+    });
+    req.pipe(proxyReq, { end: true });
+    proxyReq.on('error', (err) => {
+      res.writeHead(500);
+      res.end(err.message);
+    });
+  } catch {
+    res.writeHead(400);
+    res.end('Bad request');
+  }
+});
+
+server.on('connect', (req, clientSocket, head) => {
+  try {
+    const { port, hostname } = new URL(`http://${req.url}`);
+    if (!isAllowed(hostname)) {
+      console.log(`[HTTPS] Blocked: ${hostname}`);
+      clientSocket.write('HTTP/1.1 403 Forbidden\r\n\r\nDomain not allowed by proxy allowlist\n');
+      clientSocket.end();
+      return;
+    }
+    console.log(`[HTTPS] Allowed: ${hostname}`);
+    
+    const serverSocket = net.connect(port || 443, hostname, () => {
+      clientSocket.write('HTTP/1.1 200 Connection Established\r\n\r\n');
+      serverSocket.write(head);
+      serverSocket.pipe(clientSocket);
+      clientSocket.pipe(serverSocket);
+    });
+    serverSocket.on('error', () => clientSocket.end());
+    clientSocket.on('error', () => serverSocket.end());
+  } catch {
+    clientSocket.end();
+  }
+});
+
+server.listen(8888, () => {
+  console.log('Proxy listening on port 8888');
+});

package/templates/environments/macos-proxy/sandbox.sb

@@ -0,0 +1,34 @@
+(version 1)
+
+;; allow everything by default
+(allow default)
+
+;; deny all writes EXCEPT under specific paths
+(deny file-write*)
+(allow file-write*
+    (subpath (param "WORKSPACE"))
+    (subpath (string-append (param "HOME") "/.gemini"))
+    (subpath (string-append (param "HOME") "/.npm"))
+    (subpath (string-append (param "HOME") "/.cache"))
+    (subpath (string-append (param "HOME") "/.gitconfig"))
+    (subpath "/var")
+    (subpath "/private/var")
+    (literal "/dev/stdout")
+    (literal "/dev/stderr")
+    (literal "/dev/null")
+    (literal "/dev/ptmx")
+    (regex #"^/dev/ttys[0-9]*$")
+)
+
+;; deny all network EXCEPT local proxy and basic network operations
+(deny network-outbound)
+
+;; Allow Clawmini API
+(allow network-outbound (remote tcp "localhost:8888"))
+(allow network-outbound (remote tcp "localhost:3000"))
+
+(deny network-inbound)
+
+;; Also allow local Unix domain sockets for mDNSResponder (DNS resolution via localhost proxy might need this or just general system functionality)
+;; (allow network-outbound (literal "/private/var/run/mDNSResponder"))
+;; (allow network-outbound (remote unix-socket))

package/templates/gemini/settings.json

@@ -0,0 +1,11 @@
+{
+    "commands": {
+        "new": "gemini --output-format json --model $MODEL -p \"$CLAW_CLI_MESSAGE\"",
+        "append": "gemini --output-format json --model $MODEL --resume $SESSION_ID -p \"$CLAW_CLI_MESSAGE\"",
+        "getSessionId": "jq -r '.session_id'",
+        "getMessageContent": "jq -r '.response'"
+    },
+    "env": {
+        "MODEL": "gemini-3.1-pro-preview-customtools"
+    }
+}