@runtypelabs/cli 0.1.10 → 0.2.1

package/dist/index.js

@@ -2783,7 +2783,7 @@ var import_chalk16 = __toESM(require("chalk"));
 var import_ora11 = __toESM(require("ora"));
 var import_sdk6 = require("@runtypelabs/sdk");
 
-// src/commands/agents-run-task.ts
+// src/commands/agents-task.ts
 init_cjs_shims();
 var import_commander11 = require("commander");
 var import_chalk15 = __toESM(require("chalk"));
@@ -2810,206 +2810,546 @@ function loadState(filePath) {
 function saveState(filePath, state) {
   const dir = path4.dirname(filePath);
   fs3.mkdirSync(dir, { recursive: true });
-  state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
   fs3.writeFileSync(filePath, JSON.stringify(state, null, 2));
 }
-var runTaskCommand = new import_commander11.Command("run-task").description("Run a long-task agent with local state persistence").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 ID)").option("--state-dir <path>", "Directory for state files (default: .runtype/tasks/)").option("--resume", "Resume from existing local state").option("--track-progress", "Also sync progress to the Runtype dashboard").option("--debug", "Show debug output from each session").option("--json", "Output final result as JSON").action(
-  async (agent, options) => {
-    const apiKey = await ensureAuth();
-    if (!apiKey) return;
-    const client = new import_sdk5.RuntypeClient({
-      apiKey,
-      baseUrl: getApiUrl()
-    });
-    let agentId = agent;
-    if (!agent.startsWith("agent_")) {
-      const spinner = (0, import_ora10.default)("Looking up agent by name...").start();
-      try {
-        const list = await client.agents.list();
-        const found = list.data.find(
-          (a) => a.name.toLowerCase() === agent.toLowerCase()
-        );
-        if (found) {
-          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);
+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) {
-        spinner.fail("Failed to look up agent");
-        const message = error instanceof Error ? error.message : "Unknown error";
-        console.error(import_chalk15.default.red(message));
-        process.exit(1);
+        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 {
+          }
+        }
       }
     }
-    const taskName = options.name || agentId;
-    const filePath = stateFilePath(taskName, options.stateDir);
-    const maxSessions = parseInt(options.maxSessions, 10);
-    const maxCost = options.maxCost ? parseFloat(options.maxCost) : void 0;
-    let localState;
-    let priorSessionCount = 0;
-    let priorCost = 0;
-    if (options.resume) {
-      const existing = loadState(filePath);
-      if (!existing) {
-        console.error(import_chalk15.default.red(`No state file found at ${filePath}`));
-        console.log(import_chalk15.default.gray("  Run without --resume to start a new task."));
-        process.exit(1);
-      }
-      if (existing.status === "complete") {
-        console.log(import_chalk15.default.yellow("This task already completed."));
-        if (options.json) printJson(existing);
-        return;
-      }
-      localState = existing;
-      localState.status = "running";
-      priorSessionCount = localState.sessionCount;
-      priorCost = localState.totalCost;
-      console.log(
-        import_chalk15.default.cyan(
-          `Resuming from session ${priorSessionCount} ($${priorCost.toFixed(4)} spent)`
-        )
+  };
+}
+async function taskAction(agent, options) {
+  const apiKey = await ensureAuth();
+  if (!apiKey) return;
+  const client = new import_sdk5.RuntypeClient({
+    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();
+    try {
+      const list = await client.agents.list();
+      const found = list.data.find(
+        (a) => a.name.toLowerCase() === agent.toLowerCase()
       );
-    } else {
-      localState = {
-        agentId,
-        taskName,
-        message: options.message,
-        status: "running",
-        sessionCount: 0,
-        totalCost: 0,
-        context: {},
-        lastOutput: "",
-        sessions: [],
-        createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-      };
+      if (found) {
+        agentId = found.id;
+        spinner.succeed(`Found agent: ${import_chalk15.default.green(agentId)}`);
+      } else {
+        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 list agents");
+      const errMsg = error instanceof Error ? error.message : String(error);
+      console.error(import_chalk15.default.red(errMsg));
+      process.exit(1);
+    }
+  }
+  const taskName = options.name || agentId;
+  const filePath = stateFilePath(taskName, options.stateDir);
+  const maxSessions = parseInt(options.maxSessions, 10);
+  const maxCost = options.maxCost ? parseFloat(options.maxCost) : void 0;
+  let priorSessionCount = 0;
+  let priorCost = 0;
+  if (options.resume) {
+    const existing = loadState(filePath);
+    if (!existing) {
+      console.error(import_chalk15.default.red(`No state file found at ${filePath}`));
+      console.log(import_chalk15.default.gray("  Run without --resume to start a new task."));
+      process.exit(1);
+    }
+    if (existing.status === "complete") {
+      console.log(import_chalk15.default.yellow("This task already completed."));
+      if (options.json) printJson(existing);
+      return;
     }
-    let interrupted = false;
-    const onSigint = () => {
-      if (interrupted) process.exit(1);
-      interrupted = true;
-      console.log(import_chalk15.default.yellow("\n\nInterrupted \u2014 saving state..."));
-      localState.status = "paused";
-      saveState(filePath, localState);
+    priorSessionCount = existing.sessionCount;
+    priorCost = existing.totalCost;
+    console.log(
+      import_chalk15.default.cyan(
+        `Resuming from session ${priorSessionCount} ($${priorCost.toFixed(4)} spent)`
+      )
+    );
+  }
+  let lastKnownState = null;
+  let interrupted = false;
+  const onSigint = () => {
+    if (interrupted) process.exit(1);
+    interrupted = true;
+    console.log(import_chalk15.default.yellow("\n\nInterrupted \u2014 saving state..."));
+    if (lastKnownState) {
+      lastKnownState.status = "paused";
+      saveState(filePath, lastKnownState);
       console.log(import_chalk15.default.green(`State saved to ${filePath}`));
-      console.log(
-        import_chalk15.default.gray(
-          `  Resume with: runtype agents run-task ${agent} -m "${options.message}" --resume${options.name ? ` --name ${options.name}` : ""}`
-        )
-      );
-      process.exit(0);
-    };
-    process.on("SIGINT", onSigint);
-    const remainingSessions = maxSessions - priorSessionCount;
-    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)}` : ""}`
+        `  Resume with: ${buildResumeCommand(agent, options.message, options, parsedSandbox)}`
       )
     );
-    console.log(import_chalk15.default.gray(`  State: ${filePath}
+    process.exit(0);
+  };
+  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)}` : ""}${options.model ? ` | Model: ${options.model}` : ""}${parsedSandbox ? ` | Sandbox: ${parsedSandbox}` : ""}`
+    )
+  );
+  console.log(import_chalk15.default.gray(`  State: ${filePath}
 `));
-    try {
-      const result = await client.agents.runTask(agentId, {
-        buildMessages: (state) => {
-          const merged = { ...localState.context, ...state.context };
-          const isFirstSession = state.sessionCount === 1;
-          const totalSession = priorSessionCount + state.sessionCount;
-          if (isFirstSession && !options.resume) {
-            return [{ role: "user", content: options.message }];
+  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;
           }
-          const progress = merged.progressNotes || merged.progress;
-          const progressStr = progress ? typeof progress === "string" ? progress : JSON.stringify(progress) : "No structured progress captured yet";
-          const resumeCtx = options.resume && isFirstSession ? `
-
-Resuming from session ${priorSessionCount}. Previous context: ${JSON.stringify(localState.context)}` : "";
-          return [
-            {
-              role: "user",
-              content: `${options.message}${resumeCtx}
-
-Progress so far: ${progressStr}
-Session ${totalSession} of ${maxSessions}.`
-            }
-          ];
-        },
-        maxSessions: remainingSessions,
-        maxCost,
-        trackProgress: options.trackProgress ? taskName : void 0,
-        debugMode: options.debug,
-        onSession: (session) => {
-          const sessionCost = session.sessionCount > 1 ? session.totalCost - localState.sessions.slice(-session.sessionCount + 1).reduce((s, e) => s + e.cost, 0) : session.totalCost;
-          const thisCost = sessionCost > 0 ? sessionCost : session.totalCost / session.sessionCount;
-          localState.sessionCount = priorSessionCount + session.sessionCount;
-          localState.totalCost = priorCost + session.totalCost;
-          Object.assign(localState.context, session.context);
-          localState.lastOutput = session.lastOutput;
-          localState.status = session.status;
-          localState.sessions.push({
-            index: localState.sessionCount,
-            cost: thisCost,
-            stopReason: session.lastStopReason,
-            outputPreview: session.lastOutput.slice(0, 200),
-            at: (/* @__PURE__ */ new Date()).toISOString()
-          });
-          saveState(filePath, localState);
-          const total = localState.sessionCount;
-          const costStr = import_chalk15.default.yellow(`$${localState.totalCost.toFixed(4)}`);
-          const reasonColor = session.lastStopReason === "complete" ? import_chalk15.default.green : import_chalk15.default.gray;
-          console.log(
-            `  ${import_chalk15.default.dim(`[${total}/${maxSessions}]`)} ${reasonColor(session.lastStopReason)} | total: ${costStr}`
-          );
-          if (session.lastOutput) {
-            const preview = session.lastOutput.slice(0, 120).replace(/\n/g, " ");
-            console.log(
-              `    ${import_chalk15.default.dim(preview)}${session.lastOutput.length > 120 ? "..." : ""}`
-            );
+          process.stdout.write(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();
           }
         }
-      });
-      localState.status = result.status;
-      localState.totalCost = priorCost + result.totalCost;
-      Object.assign(localState.context, result.context);
-      saveState(filePath, localState);
-      process.removeListener("SIGINT", onSigint);
-      console.log();
-      const statusColor = result.status === "complete" ? import_chalk15.default.green : result.status === "budget_exceeded" ? import_chalk15.default.red : import_chalk15.default.yellow;
-      console.log(`Status:     ${statusColor(localState.status)}`);
-      console.log(`Sessions:   ${localState.sessionCount}`);
-      console.log(`Total cost: ${import_chalk15.default.yellow(`$${localState.totalCost.toFixed(4)}`)}`);
-      console.log(`State:      ${import_chalk15.default.gray(filePath)}`);
-      if (localState.status === "paused" || localState.status === "max_sessions") {
+      },
+      onToolStart: (event) => {
+        if (thinkingSpinner) {
+          thinkingSpinner.stop();
+          thinkingSpinner = null;
+        }
+        if (options.debug) {
+          console.log(import_chalk15.default.gray(`
+  [tool] ${event.toolName}...`));
+        }
+      },
+      onToolComplete: (event) => {
+        if (options.debug) {
+          const status = event.success ? import_chalk15.default.green("ok") : import_chalk15.default.red("failed");
+          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.gray(
+          import_chalk15.default.cyan(
             `
-Resume: runtype agents run-task ${agent} -m "${options.message}" --resume${options.name ? ` --name ${options.name}` : ""}`
+  [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}`));
       }
-      if (options.json) {
-        console.log();
-        printJson(localState);
+    };
+    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");
+        }
       }
-    } catch (error) {
-      localState.status = "paused";
-      saveState(filePath, localState);
-      process.removeListener("SIGINT", onSigint);
-      const message = error instanceof Error ? error.message : "Unknown error";
-      console.error(import_chalk15.default.red(`
-Task failed: ${message}`));
-      console.log(import_chalk15.default.gray(`State saved to ${filePath} \u2014 resume with --resume`));
-      process.exit(1);
+    };
+    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: 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 = {
+          ...state,
+          sessionCount: priorSessionCount + state.sessionCount,
+          totalCost: priorCost + state.totalCost
+        };
+        lastKnownState = adjustedState;
+        saveState(filePath, adjustedState);
+        const latest = state.sessions[state.sessions.length - 1];
+        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 : latest.stopReason === "error" ? import_chalk15.default.red : import_chalk15.default.gray;
+          console.log(
+            `
+  ${import_chalk15.default.dim(`[${total}/${maxSessions}]`)} ${reasonColor(latest.stopReason)} | total: ${costStr}`
+          );
+        }
+        if (interrupted) return false;
+      }
+    });
+    const finalState = {
+      agentId,
+      agentName: result.sessions[0]?.stopReason ? agentId : agentId,
+      taskName,
+      status: result.status,
+      sessionCount: priorSessionCount + result.sessionCount,
+      totalCost: priorCost + result.totalCost,
+      lastOutput: result.lastOutput,
+      lastStopReason: result.sessions[result.sessions.length - 1]?.stopReason || "complete",
+      sessions: result.sessions,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    saveState(filePath, finalState);
+    process.removeListener("SIGINT", onSigint);
+    console.log();
+    const statusColor = result.status === "complete" ? import_chalk15.default.green : result.status === "budget_exceeded" ? import_chalk15.default.red : import_chalk15.default.yellow;
+    console.log(`Status:     ${statusColor(result.status)}`);
+    console.log(`Sessions:   ${finalState.sessionCount}`);
+    console.log(`Total cost: ${import_chalk15.default.yellow(`$${finalState.totalCost.toFixed(4)}`)}`);
+    console.log(`State:      ${import_chalk15.default.gray(filePath)}`);
+    if (result.recordId) {
+      console.log(`Record:     ${import_chalk15.default.gray(result.recordId)}`);
+    }
+    if (result.status === "paused" || result.status === "max_sessions") {
+      console.log(
+        import_chalk15.default.gray(
+          `
+Resume: ${buildResumeCommand(agent, options.message, options, parsedSandbox)}`
+        )
+      );
+    }
+    if (options.json) {
+      console.log();
+      printJson(finalState);
+    }
+  } catch (error) {
+    const stateAtError = lastKnownState;
+    if (stateAtError) {
+      stateAtError.status = "paused";
+      saveState(filePath, stateAtError);
+    }
+    process.removeListener("SIGINT", onSigint);
+    const errMsg = error instanceof Error ? error.message : "Unknown error";
+    console.error(import_chalk15.default.red(`
+Task failed: ${errMsg}`));
+    console.log(import_chalk15.default.gray(`State saved to ${filePath} \u2014 resume with --resume`));
+    process.exit(1);
   }
+}
+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("--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")
 );
+function createMarathonCommand() {
+  return applyTaskOptions(
+    new import_commander11.Command("marathon").description("Run a multi-session agent task (alias for agents task)")
+  );
+}
 
 // src/commands/agents.ts
 var agentsCommand = new import_commander12.Command("agents").description("Manage agents");
-agentsCommand.addCommand(runTaskCommand);
+agentsCommand.addCommand(taskCommand);
 agentsCommand.command("list").description("List all agents").option("--json", "Output as JSON").option("--limit <n>", "Limit results", "20").action(async (options) => {
   const apiKey = await ensureAuth();
   if (!apiKey) return;
@@ -4077,12 +4417,15 @@ program.addCommand(apiKeysCommand);
 program.addCommand(analyticsCommand);
 program.addCommand(billingCommand);
 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;