@runtypelabs/cli 0.2.0 → 0.2.1

package/README.md

@@ -72,6 +72,13 @@ runtype marathon "Code Builder" -m "Refactor the auth module to use JWT tokens"
 runtype marathon agent_abc123 -m "Write integration tests for the API" \
   --max-sessions 10 --max-cost 2.50 --name "api-tests"
 
+# Override the agent's configured model
+runtype marathon "Code Builder" -m "Build a calculator" --model claude-sonnet-4-5
+
+# Enable sandboxed code execution tooling for the task (QuickJS or Daytona)
+runtype marathon "Code Builder" -m "Compute totals from this dataset" --sandbox quickjs
+runtype marathon "Code Builder" -m "Generate a script and run it" --sandbox daytona
+
 # Resume an interrupted task (picks up where it left off)
 runtype marathon "Code Builder" -m "Refactor the auth module to use JWT tokens" \
   --resume --name "auth-refactor" --debug

package/dist/index.js

@@ -2812,6 +2812,205 @@ function saveState(filePath, state) {
   fs3.mkdirSync(dir, { recursive: true });
   fs3.writeFileSync(filePath, JSON.stringify(state, null, 2));
 }
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseSandboxProvider(value) {
+  if (!value) return void 0;
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "quickjs" || normalized === "daytona") return normalized;
+  return void 0;
+}
+function parseSandboxLanguage(provider, value) {
+  if (provider === "quickjs") return "javascript";
+  if (typeof value === "string") {
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "javascript" || normalized === "typescript" || normalized === "python") {
+      return normalized;
+    }
+  }
+  return "javascript";
+}
+function parseSandboxTimeout(value, provider) {
+  const fallback = provider === "quickjs" ? 5e3 : 3e4;
+  let numericValue;
+  if (typeof value === "number" && Number.isFinite(value)) {
+    numericValue = value;
+  } else if (typeof value === "string" && value.trim() !== "") {
+    const parsed = Number(value);
+    if (Number.isFinite(parsed)) {
+      numericValue = parsed;
+    }
+  }
+  if (numericValue === void 0) return fallback;
+  return Math.max(1, Math.min(3e4, Math.floor(numericValue)));
+}
+function parseDaytonaExecutionResult(value) {
+  if (typeof value !== "string") return value;
+  const trimmed = value.trim();
+  if (!trimmed) return "";
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    const lines = trimmed.split("\n").map((line) => line.trim()).filter(Boolean);
+    const lastLine = lines[lines.length - 1];
+    if (!lastLine) return value;
+    try {
+      return JSON.parse(lastLine);
+    } catch {
+      return value;
+    }
+  }
+}
+function createSandboxInstructions(provider) {
+  if (provider === "quickjs") {
+    return [
+      "--- Sandbox Tooling (QuickJS) ---",
+      "You can execute JavaScript snippets with the local tool `run_sandbox_code`.",
+      "Call shape:",
+      '{ "code": "...", "parameters": { ... }, "timeoutMs": 5000 }',
+      "QuickJS rules:",
+      "1. Use JavaScript only (no TypeScript or Python).",
+      "2. Inputs are passed in the `parameters` object (for example: `const x = parameters.x`).",
+      "3. The snippet is wrapped in a function. Use top-level `return ...` to produce the result.",
+      "4. Return JSON-serializable values (object, array, string, number, boolean, null).",
+      "5. No Node/Bun/Deno APIs, imports/require, process, filesystem, or network calls.",
+      "Example:",
+      "const nums = parameters.nums || []",
+      "const sum = nums.reduce((acc, n) => acc + n, 0)",
+      "return { sum, count: nums.length }"
+    ].join("\n");
+  }
+  return [
+    "--- Sandbox Tooling (Daytona) ---",
+    "You can execute code snippets with the local tool `run_sandbox_code`.",
+    "Call shape:",
+    '{ "code": "...", "parameters": { ... }, "language": "javascript|typescript|python", "timeoutMs": 30000 }',
+    "Daytona rules:",
+    "1. Choose one language: javascript, typescript, or python.",
+    "2. Parameters are injected as top-level variables before your code (do not rely on `parameters`).",
+    "3. Your snippet runs as a full program. Do not use top-level `return`.",
+    "4. For structured results, write a single JSON value to stdout as the final output.",
+    "5. JS/TS: `console.log(JSON.stringify({ ... }))`; Python: `import json` then `print(json.dumps({ ... }))`.",
+    "6. Avoid extra logs before the final JSON line, or parsing may fail."
+  ].join("\n");
+}
+function buildResumeCommand(agent, message, options, parsedSandbox) {
+  const nameFlag = options.name ? ` --name ${options.name}` : "";
+  const sandboxFlag = parsedSandbox ? ` --sandbox ${parsedSandbox}` : "";
+  return `runtype marathon ${agent} -m "${message}" --resume${nameFlag}${sandboxFlag}`;
+}
+function createSandboxLocalTool(client, provider, debugMode) {
+  return {
+    description: provider === "quickjs" ? "Execute JavaScript code in QuickJS sandbox. Inputs are passed via parameters object." : "Execute JavaScript/TypeScript/Python code in Daytona sandbox. Inputs are injected as top-level variables.",
+    parametersSchema: {
+      type: "object",
+      properties: {
+        code: { type: "string", description: "Code snippet to execute" },
+        parameters: {
+          type: "object",
+          description: "Input parameters for the code (JSON object)"
+        },
+        language: {
+          type: "string",
+          enum: provider === "quickjs" ? ["javascript"] : ["javascript", "typescript", "python"],
+          description: provider === "quickjs" ? "QuickJS only accepts javascript" : "Daytona code language"
+        },
+        timeoutMs: { type: "number", description: "Execution timeout in ms (max 30000)" }
+      },
+      required: ["code"]
+    },
+    execute: async (args) => {
+      const rawCode = args.code;
+      const code = typeof rawCode === "string" ? rawCode : "";
+      if (!code.trim()) {
+        return { success: false, error: "code is required" };
+      }
+      const language = parseSandboxLanguage(provider, args.language);
+      const timeout = parseSandboxTimeout(args.timeoutMs, provider);
+      const parameters = isRecord(args.parameters) ? args.parameters : {};
+      const gateDecision = (0, import_sdk5.evaluateGeneratedRuntimeToolProposal)(
+        {
+          name: "run_sandbox_code",
+          description: `Execute code in ${provider}`,
+          toolType: "custom",
+          parametersSchema: { type: "object" },
+          config: {
+            code,
+            timeout,
+            sandboxProvider: provider,
+            language
+          }
+        },
+        {
+          allowedToolTypes: ["custom"],
+          allowedSandboxProviders: [provider],
+          allowedLanguages: provider === "quickjs" ? ["javascript"] : ["javascript", "typescript", "python"],
+          maxTimeoutMs: 3e4,
+          maxCodeLength: 12e3
+        }
+      );
+      if (!gateDecision.approved) {
+        return {
+          success: false,
+          error: gateDecision.reason,
+          violations: gateDecision.violations
+        };
+      }
+      const tempToolName = `marathon_${provider}_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+      let tempToolId;
+      try {
+        const createRequest = {
+          name: tempToolName,
+          description: `Ephemeral ${provider} sandbox execution`,
+          toolType: "custom",
+          parametersSchema: { type: "object", properties: {} },
+          config: {
+            code,
+            timeout,
+            allowedApis: [],
+            sandboxProvider: provider,
+            language
+          }
+        };
+        const created = await client.tools.create(createRequest);
+        tempToolId = created.id;
+        const executeRequest = {
+          toolId: created.id,
+          parameters
+        };
+        const execution = await client.tools.execute(created.id, executeRequest);
+        const parsedResult = provider === "daytona" ? parseDaytonaExecutionResult(execution.result) : execution.result;
+        return {
+          success: execution.status === "success",
+          sandboxProvider: provider,
+          language,
+          result: parsedResult,
+          executionId: execution.executionId,
+          ...execution.errorMessage ? { error: execution.errorMessage } : {}
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (debugMode) {
+          console.log(import_chalk15.default.gray(`  [sandbox:${provider}] execution error: ${message}`));
+        }
+        return {
+          success: false,
+          sandboxProvider: provider,
+          language,
+          error: message
+        };
+      } finally {
+        if (tempToolId) {
+          try {
+            await client.tools.delete(tempToolId);
+          } catch {
+          }
+        }
+      }
+    }
+  };
+}
 async function taskAction(agent, options) {
   const apiKey = await ensureAuth();
   if (!apiKey) return;
@@ -2819,6 +3018,11 @@ async function taskAction(agent, options) {
     apiKey,
     baseUrl: getApiUrl()
   });
+  const parsedSandbox = parseSandboxProvider(options.sandbox);
+  if (options.sandbox && !parsedSandbox) {
+    console.error(import_chalk15.default.red(`Invalid --sandbox value "${options.sandbox}". Use: quickjs or daytona`));
+    process.exit(1);
+  }
   let agentId = agent;
   if (!agent.startsWith("agent_")) {
     const spinner = (0, import_ora10.default)("Looking up agent by name...").start();
@@ -2831,13 +3035,21 @@ async function taskAction(agent, options) {
         agentId = found.id;
         spinner.succeed(`Found agent: ${import_chalk15.default.green(agentId)}`);
       } else {
-        spinner.fail(`No agent found with name "${agent}"`);
-        console.log(import_chalk15.default.gray(`  Create one with: runtype agents create -n "${agent}"`));
-        process.exit(1);
+        spinner.text = `Creating agent "${agent}"...`;
+        try {
+          const created = await client.agents.create({ name: agent });
+          agentId = created.id;
+          spinner.succeed(`Created agent: ${import_chalk15.default.green(agentId)}`);
+        } catch (createErr) {
+          spinner.fail(`Failed to create agent "${agent}"`);
+          const errMsg = createErr instanceof Error ? createErr.message : String(createErr);
+          console.error(import_chalk15.default.red(errMsg));
+          process.exit(1);
+        }
       }
     } catch (error) {
-      spinner.fail("Failed to look up agent");
-      const errMsg = error instanceof Error ? error.message : "Unknown error";
+      spinner.fail("Failed to list agents");
+      const errMsg = error instanceof Error ? error.message : String(error);
       console.error(import_chalk15.default.red(errMsg));
       process.exit(1);
     }
@@ -2881,7 +3093,7 @@ async function taskAction(agent, options) {
     }
     console.log(
       import_chalk15.default.gray(
-        `  Resume with: runtype marathon ${agent} -m "${options.message}" --resume${options.name ? ` --name ${options.name}` : ""}`
+        `  Resume with: ${buildResumeCommand(agent, options.message, options, parsedSandbox)}`
       )
     );
     process.exit(0);
@@ -2889,32 +3101,63 @@ async function taskAction(agent, options) {
   process.on("SIGINT", onSigint);
   const remainingSessions = maxSessions - priorSessionCount;
   const remainingCost = maxCost ? maxCost - priorCost : void 0;
+  const sandboxPrompt = parsedSandbox ? createSandboxInstructions(parsedSandbox) : "";
+  const taskMessage = sandboxPrompt ? `${options.message}
+
+${sandboxPrompt}` : options.message;
   console.log(import_chalk15.default.cyan(`
 Running task "${taskName}" on ${agentId}`));
   console.log(
     import_chalk15.default.gray(
-      `  Sessions: ${priorSessionCount > 0 ? `${priorSessionCount} done, ` : ""}${remainingSessions} remaining${maxCost ? ` | Budget: $${maxCost.toFixed(2)}` : ""}`
+      `  Sessions: ${priorSessionCount > 0 ? `${priorSessionCount} done, ` : ""}${remainingSessions} remaining${maxCost ? ` | Budget: $${maxCost.toFixed(2)}` : ""}${options.model ? ` | Model: ${options.model}` : ""}${parsedSandbox ? ` | Sandbox: ${parsedSandbox}` : ""}`
     )
   );
   console.log(import_chalk15.default.gray(`  State: ${filePath}
 `));
   try {
     let currentSession = priorSessionCount;
+    let thinkingSpinner = null;
+    let thinkingChars = 0;
     const streamCallbacks = {
       onAgentStart: () => {
         currentSession++;
         console.log(import_chalk15.default.cyan(`
 \u2500\u2500 Session ${currentSession} \u2500\u2500
 `));
+        thinkingChars = 0;
+        thinkingSpinner = (0, import_ora10.default)({ text: import_chalk15.default.dim("Thinking..."), color: "gray" }).start();
       },
       onTurnDelta: (event) => {
         if (event.contentType === "text") {
+          if (thinkingSpinner) {
+            thinkingSpinner.stop();
+            thinkingSpinner = null;
+          }
           process.stdout.write(event.delta);
-        } else if (event.contentType === "thinking" && options.debug) {
-          process.stdout.write(import_chalk15.default.dim(event.delta));
+        } else if (event.contentType === "thinking") {
+          thinkingChars += event.delta.length;
+          const approxTokens = Math.round(thinkingChars / 4);
+          const tokenStr = approxTokens.toLocaleString();
+          if (!thinkingSpinner) {
+            thinkingSpinner = (0, import_ora10.default)({
+              text: import_chalk15.default.dim(`Thinking... (~${tokenStr} tokens)`),
+              color: "gray"
+            }).start();
+          } else {
+            thinkingSpinner.text = import_chalk15.default.dim(`Thinking... (~${tokenStr} tokens)`);
+          }
+          if (options.debug) {
+            thinkingSpinner.stop();
+            process.stdout.write(import_chalk15.default.dim(event.delta));
+            thinkingSpinner.start();
+          }
         }
       },
       onToolStart: (event) => {
+        if (thinkingSpinner) {
+          thinkingSpinner.stop();
+          thinkingSpinner = null;
+        }
         if (options.debug) {
           console.log(import_chalk15.default.gray(`
   [tool] ${event.toolName}...`));
@@ -2926,18 +3169,100 @@ Running task "${taskName}" on ${agentId}`));
           console.log(import_chalk15.default.gray(`  [tool] ${event.toolName} \u2192 ${status}`));
         }
       },
+      onAgentPaused: (event) => {
+        if (thinkingSpinner) {
+          thinkingSpinner.stop();
+          thinkingSpinner = null;
+        }
+        const rawParams = event.parameters;
+        const paramPreview = typeof rawParams === "string" ? `string(${rawParams.length} chars)` : rawParams && typeof rawParams === "object" ? `object(${Object.keys(rawParams).join(", ")})` : typeof rawParams;
+        console.log(
+          import_chalk15.default.cyan(
+            `
+  [local tool] ${event.toolName} called (params: ${paramPreview})`
+          )
+        );
+        if (options.debug) {
+          console.log(import_chalk15.default.gray(`    executionId: ${event.executionId}`));
+          console.log(import_chalk15.default.gray(`    raw params: ${JSON.stringify(event.parameters).slice(0, 300)}`));
+        }
+      },
       onError: (event) => {
+        if (thinkingSpinner) {
+          thinkingSpinner.stop();
+          thinkingSpinner = null;
+        }
         console.error(import_chalk15.default.red(`
   Error: ${event.error}`));
       }
     };
+    const defaultLocalTools = {
+      read_file: {
+        description: "Read the contents of a file at the given path",
+        parametersSchema: {
+          type: "object",
+          properties: { path: { type: "string", description: "File path to read" } },
+          required: ["path"]
+        },
+        execute: async (args) => {
+          const filePath2 = String(args.path || "");
+          if (!filePath2) return "Error: path is required";
+          return fs3.readFileSync(filePath2, "utf-8");
+        }
+      },
+      write_file: {
+        description: "Write content to a file, creating directories as needed",
+        parametersSchema: {
+          type: "object",
+          properties: {
+            path: { type: "string", description: "File path to write" },
+            content: { type: "string", description: "Content to write" }
+          },
+          required: ["path", "content"]
+        },
+        execute: async (args) => {
+          const filePath2 = String(args.path || "");
+          if (!filePath2) return "Error: path is required";
+          const content = String(args.content || "");
+          const dir = path4.dirname(filePath2);
+          fs3.mkdirSync(dir, { recursive: true });
+          fs3.writeFileSync(filePath2, content);
+          return "ok";
+        }
+      },
+      list_directory: {
+        description: "List files and directories at the given path",
+        parametersSchema: {
+          type: "object",
+          properties: { path: { type: "string", description: 'Directory path (defaults to ".")' } }
+        },
+        execute: async (args) => {
+          const dirPath = String(args.path || ".");
+          return fs3.readdirSync(dirPath).join("\n");
+        }
+      }
+    };
+    const enabledLocalTools = {};
+    if (!options.noLocalTools) {
+      Object.assign(enabledLocalTools, defaultLocalTools);
+    }
+    if (parsedSandbox) {
+      enabledLocalTools.run_sandbox_code = createSandboxLocalTool(
+        client,
+        parsedSandbox,
+        options.debug
+      );
+    }
+    const localTools = Object.keys(enabledLocalTools).length > 0 ? enabledLocalTools : void 0;
     const result = await client.agents.runTask(agentId, {
-      message: options.message,
+      message: taskMessage,
       maxSessions: remainingSessions,
       maxCost: remainingCost,
+      model: options.model,
       debugMode: options.debug,
       stream: true,
       streamCallbacks,
+      localTools,
       trackProgress: options.track ? taskName : void 0,
       onSession: (state) => {
         const adjustedState = {
@@ -2951,7 +3276,7 @@ Running task "${taskName}" on ${agentId}`));
         if (latest) {
           const total = adjustedState.sessionCount;
           const costStr = import_chalk15.default.yellow(`$${adjustedState.totalCost.toFixed(4)}`);
-          const reasonColor = latest.stopReason === "complete" ? import_chalk15.default.green : import_chalk15.default.gray;
+          const reasonColor = latest.stopReason === "complete" ? import_chalk15.default.green : latest.stopReason === "error" ? import_chalk15.default.red : import_chalk15.default.gray;
           console.log(
             `
   ${import_chalk15.default.dim(`[${total}/${maxSessions}]`)} ${reasonColor(latest.stopReason)} | total: ${costStr}`
@@ -2988,7 +3313,7 @@ Running task "${taskName}" on ${agentId}`));
       console.log(
         import_chalk15.default.gray(
           `
-Resume: runtype marathon ${agent} -m "${options.message}" --resume${options.name ? ` --name ${options.name}` : ""}`
+Resume: ${buildResumeCommand(agent, options.message, options, parsedSandbox)}`
         )
       );
     }
@@ -3011,7 +3336,7 @@ Task failed: ${errMsg}`));
   }
 }
 function applyTaskOptions(cmd) {
-  return cmd.argument("<agent>", "Agent ID or name").requiredOption("-m, --message <text>", "Task message for the agent").option("--max-sessions <n>", "Maximum sessions", "50").option("--max-cost <n>", "Budget in USD").option("--name <name>", "Task name (used for state file, defaults to agent name)").option("--state-dir <path>", "Directory for state files (default: .runtype/tasks/)").option("--resume", "Resume from existing local state").option("--track", "Sync progress to a Runtype record (visible in dashboard)").option("--debug", "Show debug output from each session").option("--json", "Output final result as JSON").action(taskAction);
+  return cmd.argument("<agent>", "Agent ID or name").requiredOption("-m, --message <text>", "Task message for the agent").option("--max-sessions <n>", "Maximum sessions", "50").option("--max-cost <n>", "Budget in USD").option("--model <modelId>", "Model ID to use (overrides agent config)").option("--name <name>", "Task name (used for state file, defaults to agent name)").option("--state-dir <path>", "Directory for state files (default: .runtype/tasks/)").option("--resume", "Resume from existing local state").option("--track", "Sync progress to a Runtype record (visible in dashboard)").option("--debug", "Show debug output from each session").option("--json", "Output final result as JSON").option("--sandbox <provider>", "Enable sandbox code execution tool (quickjs or daytona)").option("--no-local-tools", "Disable built-in local tool execution (read_file, write_file, list_directory)").action(taskAction);
 }
 var taskCommand = applyTaskOptions(
   new import_commander11.Command("task").description("Run a multi-session agent task")
@@ -4095,10 +4420,12 @@ program.addCommand(flowVersionsCommand);
 program.addCommand(createMarathonCommand());
 program.exitOverride();
 try {
-  if (!process.argv.slice(2).length) {
+  const userArgs = process.argv.slice(2);
+  const cleanArgs = userArgs[0] === "--" ? userArgs.slice(1) : userArgs;
+  if (!cleanArgs.length) {
     handleNoCommand();
   } else {
-    program.parse(process.argv);
+    program.parse(cleanArgs, { from: "user" });
   }
 } catch (error) {
   const commanderError = error;