@bike4mind/cli 0.2.60 → 0.2.61-feat-pi-intelligence-visibility.21705

package/dist/{artifactExtractor-YB2LOUUT.js → artifactExtractor-UI7MK2WJ.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   CurationArtifactType
-} from "./chunk-3YQJY7XO.js";
+} from "./chunk-HD2W2IIP.js";
 
 // ../../b4m-core/packages/services/dist/src/notebookCurationService/artifactExtractor.js
 var ARTIFACT_TAG_REGEX = /<artifact\s+(.*?)>([\s\S]*?)<\/artifact>/gi;

package/dist/bashExecute-GLGLD3JD.js

@@ -0,0 +1,379 @@
+#!/usr/bin/env node
+
+// ../../b4m-core/packages/services/dist/src/llm/tools/implementation/bashExecute/index.js
+import { spawn } from "child_process";
+import path from "path";
+var DEFAULT_TIMEOUT_MS = 6e4;
+var MAX_OUTPUT_SIZE = 100 * 1024;
+var DANGEROUS_PATTERNS = [
+  // Destructive file operations
+  {
+    pattern: /\brm\s+(-[a-zA-Z]*r[a-zA-Z]*\s+|.*\s+-[a-zA-Z]*r).*\//i,
+    reason: "Recursive delete with path",
+    block: true
+  },
+  {
+    pattern: /\brm\s+(-[a-zA-Z]*f[a-zA-Z]*\s+|.*\s+-[a-zA-Z]*f).*--no-preserve-root/i,
+    reason: "Force delete without preserve root",
+    block: true
+  },
+  {
+    pattern: /\brm\s+-[a-zA-Z]*r[a-zA-Z]*f[a-zA-Z]*\s+\//i,
+    reason: "Recursive force delete on root paths",
+    block: true
+  },
+  {
+    pattern: /\brm\s+-[a-zA-Z]*f[a-zA-Z]*r[a-zA-Z]*\s+\//i,
+    reason: "Force recursive delete on root paths",
+    block: true
+  },
+  // System-level dangerous commands
+  { pattern: /\bsudo\b/i, reason: "Elevated privileges (sudo)", block: true },
+  { pattern: /\bsu\s+(-|root)/i, reason: "Switch to root user", block: true },
+  { pattern: /\bchmod\s+777\b/i, reason: "Overly permissive chmod", block: false },
+  { pattern: /\bchown\s+-R\s+root/i, reason: "Recursive chown to root", block: true },
+  // Disk/partition operations
+  { pattern: /\bmkfs\b/i, reason: "Filesystem creation", block: true },
+  { pattern: /\bfdisk\b/i, reason: "Disk partitioning", block: true },
+  { pattern: /\bdd\s+.*of=\/dev\//i, reason: "Direct disk write", block: true },
+  // Network attacks
+  { pattern: /\b(nc|netcat)\s+.*-e\s+\/bin\/(ba)?sh/i, reason: "Reverse shell attempt", block: true },
+  { pattern: /\bcurl\s+.*\|\s*(ba)?sh/i, reason: "Piping remote script to shell", block: true },
+  { pattern: /\bwget\s+.*\|\s*(ba)?sh/i, reason: "Piping remote script to shell", block: true },
+  // Fork bombs and resource exhaustion
+  { pattern: /:\(\)\s*\{\s*:\|:&\s*\}\s*;/i, reason: "Fork bomb", block: true },
+  { pattern: /\bwhile\s+true.*do.*done.*&/i, reason: "Infinite loop in background", block: false },
+  // Credential/sensitive data access
+  { pattern: /\/etc\/shadow/i, reason: "Access to shadow file", block: true },
+  { pattern: /\/etc\/passwd.*>/i, reason: "Modifying passwd file", block: true },
+  { pattern: /\baws\s+.*--profile\s+/i, reason: "AWS profile access", block: false },
+  // History/log manipulation
+  { pattern: /\bhistory\s+-c\b/i, reason: "Clearing shell history", block: false },
+  { pattern: />\s*\/var\/log\//i, reason: "Overwriting system logs", block: true },
+  // Dangerous redirects
+  { pattern: />\s*\/dev\/sda/i, reason: "Writing to block device", block: true },
+  { pattern: />\s*\/dev\/null.*2>&1.*</i, reason: "Potentially hiding output", block: false },
+  // Environment manipulation
+  { pattern: /\bexport\s+PATH\s*=\s*[^$]/i, reason: "Overwriting PATH", block: false },
+  { pattern: /\bexport\s+LD_PRELOAD/i, reason: "LD_PRELOAD manipulation", block: true },
+  // Process/system control
+  { pattern: /\bkill\s+-9\s+(-1|1)\b/i, reason: "Killing all processes", block: true },
+  { pattern: /\bkillall\s+-9\b/i, reason: "Force killing processes", block: false },
+  { pattern: /\bshutdown\b/i, reason: "System shutdown", block: true },
+  { pattern: /\breboot\b/i, reason: "System reboot", block: true },
+  { pattern: /\binit\s+[06]\b/i, reason: "System runlevel change", block: true }
+];
+var SAFE_COMMAND_PREFIXES = [
+  "ls",
+  "cat",
+  "head",
+  "tail",
+  "grep",
+  "find",
+  "echo",
+  "pwd",
+  "whoami",
+  "date",
+  "cal",
+  "wc",
+  "sort",
+  "uniq",
+  "cut",
+  "tr",
+  "sed",
+  "awk",
+  "git",
+  "npm",
+  "pnpm",
+  "yarn",
+  "node",
+  "npx",
+  "tsx",
+  "ts-node",
+  "python",
+  "python3",
+  "pip",
+  "pip3",
+  "docker",
+  "docker-compose",
+  "curl",
+  "wget",
+  // These are safe for fetching, blocked when piped to shell
+  "mkdir",
+  "touch",
+  "cp",
+  "mv",
+  // File operations (still require permission)
+  "which",
+  "whereis",
+  "type",
+  "file",
+  "stat",
+  "env",
+  "printenv",
+  "set",
+  "man",
+  "help",
+  "info",
+  "diff",
+  "comm",
+  "cmp",
+  "tar",
+  "zip",
+  "unzip",
+  "gzip",
+  "gunzip",
+  "ssh",
+  "scp",
+  "rsync",
+  // Network tools
+  "make",
+  "cmake",
+  "cargo",
+  "go",
+  "rustc",
+  "gcc",
+  "g++",
+  // Build tools
+  "jest",
+  "vitest",
+  "mocha",
+  "pytest",
+  // Test runners
+  "eslint",
+  "prettier",
+  "tsc"
+  // Linters/formatters
+];
+function checkDangerousPatterns(command) {
+  for (const { pattern, reason, block } of DANGEROUS_PATTERNS) {
+    if (pattern.test(command)) {
+      return { blocked: block, reason };
+    }
+  }
+  return { blocked: false };
+}
+function getBaseCommand(command) {
+  const trimmed = command.trim();
+  const match = trimmed.match(/^(\S+)/);
+  return match ? match[1] : "";
+}
+function isSafeCommandPrefix(command) {
+  const baseCommand = getBaseCommand(command);
+  return SAFE_COMMAND_PREFIXES.some((safe) => baseCommand === safe || baseCommand.endsWith(`/${safe}`));
+}
+async function executeBashCommand(params) {
+  const { command, cwd: relativeCwd, timeout = DEFAULT_TIMEOUT_MS } = params;
+  if (!command || command.trim().length === 0) {
+    return {
+      stdout: "",
+      stderr: "Error: Command cannot be empty",
+      exitCode: 1,
+      timedOut: false,
+      blocked: true,
+      blockedReason: "Empty command"
+    };
+  }
+  const dangerCheck = checkDangerousPatterns(command);
+  if (dangerCheck.blocked) {
+    return {
+      stdout: "",
+      stderr: `Command blocked for safety: ${dangerCheck.reason}`,
+      exitCode: 1,
+      timedOut: false,
+      blocked: true,
+      blockedReason: dangerCheck.reason
+    };
+  }
+  const baseCwd = process.cwd();
+  const targetCwd = relativeCwd ? path.resolve(baseCwd, relativeCwd) : baseCwd;
+  const effectiveTimeout = Math.min(timeout, 5 * 60 * 1e3);
+  return new Promise((resolve) => {
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    const proc = spawn("bash", ["-c", command], {
+      cwd: targetCwd,
+      env: {
+        ...process.env,
+        // Prevent color codes that might be hard to read
+        NO_COLOR: "1",
+        FORCE_COLOR: "0"
+      },
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const timeoutId = setTimeout(() => {
+      timedOut = true;
+      proc.kill("SIGTERM");
+      setTimeout(() => {
+        if (!proc.killed) {
+          proc.kill("SIGKILL");
+        }
+      }, 5e3);
+    }, effectiveTimeout);
+    proc.stdout.on("data", (data) => {
+      if (stdout.length < MAX_OUTPUT_SIZE) {
+        stdout += data.toString();
+        if (stdout.length > MAX_OUTPUT_SIZE) {
+          stdout = stdout.slice(0, MAX_OUTPUT_SIZE) + "\n... [output truncated]";
+        }
+      }
+    });
+    proc.stderr.on("data", (data) => {
+      if (stderr.length < MAX_OUTPUT_SIZE) {
+        stderr += data.toString();
+        if (stderr.length > MAX_OUTPUT_SIZE) {
+          stderr = stderr.slice(0, MAX_OUTPUT_SIZE) + "\n... [output truncated]";
+        }
+      }
+    });
+    proc.on("close", (exitCode) => {
+      clearTimeout(timeoutId);
+      resolve({
+        stdout: stdout.trim(),
+        stderr: stderr.trim(),
+        exitCode,
+        timedOut,
+        blocked: false
+      });
+    });
+    proc.on("error", (error) => {
+      clearTimeout(timeoutId);
+      resolve({
+        stdout: "",
+        stderr: `Failed to execute command: ${error.message}`,
+        exitCode: 1,
+        timedOut: false,
+        blocked: false
+      });
+    });
+  });
+}
+function formatResult(result, command) {
+  const parts = [];
+  parts.push(`$ ${command}`);
+  parts.push("");
+  if (result.blocked) {
+    parts.push(`BLOCKED: ${result.blockedReason}`);
+    parts.push("");
+    parts.push("This command was blocked for safety reasons.");
+    parts.push("If you believe this is a false positive, please run the command manually.");
+    return parts.join("\n");
+  }
+  if (result.timedOut) {
+    parts.push("WARNING: Command timed out and was terminated.");
+    parts.push("");
+  }
+  if (result.stdout) {
+    parts.push(result.stdout);
+  }
+  if (result.stderr) {
+    if (result.stdout) {
+      parts.push("");
+    }
+    parts.push("STDERR:");
+    parts.push(result.stderr);
+  }
+  if (result.exitCode !== 0 && result.exitCode !== null) {
+    parts.push("");
+    parts.push(`Exit code: ${result.exitCode}`);
+  }
+  if (!result.stdout && !result.stderr && !result.timedOut) {
+    parts.push("(command completed with no output)");
+  }
+  return parts.join("\n");
+}
+var bashExecuteTool = {
+  name: "bash_execute",
+  implementation: (context) => ({
+    toolFn: async (value) => {
+      const params = value;
+      const isSafe = isSafeCommandPrefix(params.command);
+      context.logger.info("Bash: Executing command", {
+        command: params.command,
+        cwd: params.cwd || ".",
+        timeout: params.timeout || DEFAULT_TIMEOUT_MS,
+        isSafeCommand: isSafe
+      });
+      if (context.onStart) {
+        await context.onStart("bash_execute", {
+          command: params.command,
+          cwd: params.cwd
+        });
+      }
+      try {
+        const result = await executeBashCommand(params);
+        const formattedResult = formatResult(result, params.command);
+        context.logger.info("Bash: Command completed", {
+          exitCode: result.exitCode,
+          timedOut: result.timedOut,
+          blocked: result.blocked
+        });
+        if (context.onFinish) {
+          await context.onFinish("bash_execute", {
+            command: params.command,
+            exitCode: result.exitCode,
+            blocked: result.blocked
+          });
+        }
+        return formattedResult;
+      } catch (error) {
+        context.logger.error("Bash: Command failed", error);
+        if (context.onFinish) {
+          await context.onFinish("bash_execute", {
+            command: params.command,
+            error: error instanceof Error ? error.message : "Unknown error"
+          });
+        }
+        throw error;
+      }
+    },
+    toolSchema: {
+      name: "bash_execute",
+      description: `Execute a bash command in the terminal. Use this for running shell commands, scripts, build tools, git operations, and other CLI tasks.
+
+SAFETY NOTES:
+- Commands are executed in the current working directory (or specified cwd)
+- Dangerous commands (sudo, rm -rf /, etc.) are automatically blocked
+- Commands have a default timeout of 60 seconds (max 5 minutes)
+- Output is limited to prevent overwhelming responses
+- This tool ALWAYS requires user permission before execution
+
+COMMON USE CASES:
+- Running build commands: npm run build, make, cargo build
+- Git operations: git status, git log, git diff
+- Viewing system info: ls, pwd, cat, head, tail
+- Running tests: npm test, pytest, cargo test
+- Package management: npm install, pip install
+- File operations: mkdir, cp, mv (with permission)
+
+BLOCKED OPERATIONS:
+- sudo and privilege escalation
+- Recursive deletes on system paths
+- Direct disk operations
+- Fork bombs and resource exhaustion
+- Piping remote scripts to shell`,
+      parameters: {
+        type: "object",
+        properties: {
+          command: {
+            type: "string",
+            description: "The bash command to execute. Can include pipes, redirects, and chained commands."
+          },
+          cwd: {
+            type: "string",
+            description: "Working directory for the command (optional). Can be relative or absolute path. Defaults to current directory."
+          },
+          timeout: {
+            type: "number",
+            description: "Timeout in milliseconds (optional, default: 60000, max: 300000). Command will be terminated if it exceeds this time."
+          }
+        },
+        required: ["command"]
+      }
+    }
+  })
+};
+export {
+  bashExecuteTool
+};

package/dist/{chunk-I6CFAOBC.js → chunk-43D4HP62.js}

@@ -7,11 +7,11 @@ import {
   getSettingsMap,
   getSettingsValue,
   secureParameters
-} from "./chunk-VFTGF46N.js";
+} from "./chunk-MRD767FA.js";
 import {
   KnowledgeType,
   SupportedFabFileMimeTypes
-} from "./chunk-3YQJY7XO.js";
+} from "./chunk-HD2W2IIP.js";
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/create.js
 import { z } from "zod";

package/dist/{chunk-3BBKI54Z.js → chunk-BHX4ZDRS.js}

@@ -3,7 +3,7 @@
 // package.json
 var package_default = {
   name: "@bike4mind/cli",
-  version: "0.2.60",
+  version: "0.2.61-feat-pi-intelligence-visibility.21705+4927fe8fb",
   type: "module",
   description: "Interactive CLI tool for Bike4Mind with ReAct agents",
   license: "UNLICENSED",
@@ -118,11 +118,11 @@ var package_default = {
     zustand: "^4.5.4"
   },
   devDependencies: {
-    "@bike4mind/agents": "0.2.4",
-    "@bike4mind/common": "2.73.0",
-    "@bike4mind/mcp": "1.33.18",
-    "@bike4mind/services": "2.68.0",
-    "@bike4mind/utils": "2.15.12",
+    "@bike4mind/agents": "0.2.5-feat-pi-intelligence-visibility.21705+4927fe8fb",
+    "@bike4mind/common": "2.73.1-feat-pi-intelligence-visibility.21705+4927fe8fb",
+    "@bike4mind/mcp": "1.33.19-feat-pi-intelligence-visibility.21705+4927fe8fb",
+    "@bike4mind/services": "2.68.1-feat-pi-intelligence-visibility.21705+4927fe8fb",
+    "@bike4mind/utils": "2.15.13-feat-pi-intelligence-visibility.21705+4927fe8fb",
     "@types/better-sqlite3": "^7.6.13",
     "@types/jsonwebtoken": "^9.0.4",
     "@types/node": "^22.9.0",
@@ -139,7 +139,7 @@ var package_default = {
   optionalDependencies: {
     "@vscode/ripgrep": "^1.17.1"
   },
-  gitHead: "12403427aa932671a61ac8fd7fe50d2a50b9f4f7"
+  gitHead: "4927fe8fbd64bba4678d9c9971fa3dd99ca98ab3"
 };
 
 // src/utils/updateChecker.ts

package/dist/{chunk-R5RVIU2Q.js → chunk-FIQZKJJW.js}

@@ -2,7 +2,7 @@
 import {
   BadRequestError,
   secureParameters
-} from "./chunk-VFTGF46N.js";
+} from "./chunk-MRD767FA.js";
 import {
   CompletionApiUsageTransaction,
   GenericCreditDeductTransaction,
@@ -13,7 +13,7 @@ import {
   ToolUsageTransaction,
   TransferCreditTransaction,
   VideoGenerationUsageTransaction
-} from "./chunk-3YQJY7XO.js";
+} from "./chunk-HD2W2IIP.js";
 
 // ../../b4m-core/packages/services/dist/src/creditService/subtractCredits.js
 import { z } from "zod";

package/dist/{chunk-3YQJY7XO.js → chunk-HD2W2IIP.js}

@@ -111,6 +111,9 @@ var ChatModels;
   ChatModels2["GPT5_1_CHAT_LATEST"] = "gpt-5.1-chat-latest";
   ChatModels2["GPT5_2"] = "gpt-5.2";
   ChatModels2["GPT5_2_CHAT_LATEST"] = "gpt-5.2-chat-latest";
+  ChatModels2["GPT5_4"] = "gpt-5.4";
+  ChatModels2["GPT5_4_MINI"] = "gpt-5.4-mini";
+  ChatModels2["GPT5_4_NANO"] = "gpt-5.4-nano";
   ChatModels2["LLAMA3_INSTRUCT_8B_V1"] = "meta.llama3-8b-instruct-v1:0";
   ChatModels2["LLAMA3_INSTRUCT_70B_V1"] = "meta.llama3-70b-instruct-v1:0";
   ChatModels2["LLAMA4_MAVERICK_17B_INSTRUCT_BEDROCK"] = "us.meta.llama4-maverick-17b-instruct-v1:0";
@@ -2020,6 +2023,21 @@ var TavernHeartbeatLogAction = z11.object({
     }).optional()
   })
 });
+var TavernQuestUpdateAction = z11.object({
+  action: z11.literal("tavern_quest_update"),
+  /** The full refreshed quest list (top-level only, no sub-quests) */
+  quests: z11.array(z11.object({
+    _id: z11.string(),
+    title: z11.string(),
+    description: z11.string(),
+    postedByAgentName: z11.string(),
+    claimedByAgentName: z11.string().optional(),
+    status: z11.enum(["open", "claimed", "completed", "expired"]),
+    difficulty: z11.enum(["easy", "medium", "hard"]).optional(),
+    completionNote: z11.string().optional(),
+    createdAt: z11.string()
+  }))
+});
 var SessionCreatedAction = shareableDocumentSchema.extend({
   action: z11.literal("session.created"),
   id: z11.string(),
@@ -2095,6 +2113,7 @@ var MessageDataToClient = z11.discriminatedUnion("action", [
   KeepCommandResultAction,
   TavernSceneBroadcastAction,
   TavernHeartbeatLogAction,
+  TavernQuestUpdateAction,
   JupyterNotebookProgressAction,
   DataLakeBatchProgressAction
 ]);
@@ -12031,6 +12050,7 @@ export {
   TavernSceneCommandRequestAction,
   TavernSceneBroadcastAction,
   TavernHeartbeatLogAction,
+  TavernQuestUpdateAction,
   SessionCreatedAction,
   MessageDataToServer,
   MessageDataToClient,