@thyme-sh/cli 0.2.0

package/dist/index.js

@@ -0,0 +1,1127 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/init.ts
+import { existsSync } from "fs";
+import { mkdir, writeFile } from "fs/promises";
+import { join } from "path";
+
+// src/utils/ui.ts
+import * as clack from "@clack/prompts";
+import pc from "picocolors";
+function intro2(title) {
+  clack.intro(pc.bgCyan(pc.black(` ${title} `)));
+}
+function outro2(message) {
+  clack.outro(message);
+}
+function error(message) {
+  clack.log.error(pc.red(message));
+}
+function info(message) {
+  clack.log.info(pc.cyan(message));
+}
+function warn(message) {
+  clack.log.warn(pc.yellow(message));
+}
+function step(message) {
+  clack.log.step(message);
+}
+function log2(message) {
+  console.log(message);
+}
+
+// src/commands/init.ts
+async function initCommand(projectName) {
+  intro2("Thyme CLI - Initialize Project");
+  let finalProjectName = projectName;
+  if (!finalProjectName) {
+    const name = await clack.text({
+      message: "What is your project name?",
+      placeholder: "my-thyme-project",
+      validate: (value) => {
+        if (!value) return "Project name is required";
+        if (!/^[a-z0-9-]+$/.test(value))
+          return "Project name must be lowercase alphanumeric with hyphens";
+      }
+    });
+    if (clack.isCancel(name)) {
+      clack.cancel("Operation cancelled");
+      process.exit(0);
+    }
+    finalProjectName = name;
+  }
+  const projectPath = join(process.cwd(), finalProjectName);
+  if (existsSync(projectPath)) {
+    error(`Directory "${finalProjectName}" already exists`);
+    process.exit(1);
+  }
+  const spinner = clack.spinner();
+  spinner.start("Creating project structure...");
+  try {
+    await mkdir(projectPath, { recursive: true });
+    await mkdir(join(projectPath, "functions"), { recursive: true });
+    const packageJson = {
+      name: finalProjectName,
+      version: "0.1.0",
+      type: "module",
+      private: true,
+      scripts: {
+        dev: "thyme run"
+      },
+      dependencies: {
+        "@thyme-sh/sdk": "^0.1.0",
+        viem: "^2.21.54",
+        zod: "^3.24.1"
+      },
+      devDependencies: {
+        "@thyme-sh/cli": "^0.1.0",
+        typescript: "^5.7.2"
+      }
+    };
+    await writeFile(
+      join(projectPath, "package.json"),
+      JSON.stringify(packageJson, null, 2)
+    );
+    const tsconfig = {
+      compilerOptions: {
+        target: "ES2022",
+        module: "ESNext",
+        moduleResolution: "bundler",
+        lib: ["ES2022", "DOM"],
+        strict: true,
+        esModuleInterop: true,
+        skipLibCheck: true,
+        forceConsistentCasingInFileNames: true,
+        resolveJsonModule: true
+      },
+      include: ["functions/**/*"]
+    };
+    await writeFile(
+      join(projectPath, "tsconfig.json"),
+      JSON.stringify(tsconfig, null, 2)
+    );
+    const envExample = `# Simulation settings (for --simulate flag)
+RPC_URL=https://eth-sepolia.g.alchemy.com/v2/your-key
+SIMULATE_ACCOUNT=0x742d35Cc6634C0532925a3b844Bc454e4438f44e
+
+# Cloud authentication (set by \`thyme login\`)
+THYME_AUTH_TOKEN=
+
+# Cloud API URL (required - your Convex deployment URL)
+# Example: https://your-deployment.convex.cloud
+THYME_API_URL=
+`;
+    await writeFile(join(projectPath, ".env.example"), envExample);
+    const gitignore = `node_modules/
+dist/
+.env
+.env.local
+*.log
+`;
+    await writeFile(join(projectPath, ".gitignore"), gitignore);
+    const readme = `# ${finalProjectName}
+
+A Thyme project for Web3 automation tasks.
+
+## Getting Started
+
+\`\`\`bash
+# Install dependencies
+npm install
+
+# Create a new task
+thyme new my-task
+
+# Run a task locally
+thyme run my-task
+
+# Simulate on-chain
+thyme run my-task --simulate
+
+# Deploy to cloud
+thyme login
+thyme upload my-task
+\`\`\`
+
+## Project Structure
+
+\`\`\`
+functions/
+  my-task/
+    index.ts      # Task definition
+    args.json     # Test arguments
+\`\`\`
+`;
+    await writeFile(join(projectPath, "README.md"), readme);
+    spinner.stop("Project created successfully!");
+    outro2(
+      `${pc.green("\u2713")} Project initialized!
+
+Next steps:
+  ${pc.cyan("cd")} ${finalProjectName}
+  ${pc.cyan("npm install")}
+  ${pc.cyan("thyme new")} my-task
+  ${pc.cyan("thyme run")} my-task`
+    );
+  } catch (err) {
+    spinner.stop("Failed to create project");
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+}
+
+// src/utils/tasks.ts
+import { existsSync as existsSync2 } from "fs";
+import { readdir } from "fs/promises";
+import { join as join2 } from "path";
+async function discoverTasks(projectRoot) {
+  const functionsDir = join2(projectRoot, "functions");
+  if (!existsSync2(functionsDir)) {
+    return [];
+  }
+  try {
+    const entries = await readdir(functionsDir, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory()).filter((e) => existsSync2(join2(functionsDir, e.name, "index.ts"))).map((e) => e.name);
+  } catch {
+    return [];
+  }
+}
+function getTaskPath(projectRoot, taskName) {
+  return join2(projectRoot, "functions", taskName, "index.ts");
+}
+function getTaskArgsPath(projectRoot, taskName) {
+  return join2(projectRoot, "functions", taskName, "args.json");
+}
+function isThymeProject(projectRoot) {
+  const functionsDir = join2(projectRoot, "functions");
+  return existsSync2(functionsDir);
+}
+
+// src/commands/list.ts
+async function listCommand() {
+  intro2("Thyme CLI - List Tasks");
+  const projectRoot = process.cwd();
+  if (!isThymeProject(projectRoot)) {
+    outro2(pc.red("Not in a Thyme project"));
+    process.exit(1);
+  }
+  const tasks = await discoverTasks(projectRoot);
+  if (tasks.length === 0) {
+    outro2(pc.yellow("No tasks found. Create one with `thyme new`"));
+    return;
+  }
+  step(`Found ${tasks.length} task(s):`);
+  for (const task of tasks) {
+    console.log(`  ${pc.cyan("\u25CF")} ${task}`);
+  }
+  outro2("");
+}
+
+// src/commands/login.ts
+import { existsSync as existsSync4 } from "fs";
+import { appendFile, readFile, writeFile as writeFile2 } from "fs/promises";
+import { join as join4 } from "path";
+
+// src/utils/env.ts
+import { existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+import { config } from "dotenv";
+function loadEnv(projectRoot) {
+  const envPath = join3(projectRoot, ".env");
+  if (existsSync3(envPath)) {
+    config({ path: envPath });
+  }
+}
+function getEnv(key, fallback) {
+  return process.env[key] ?? fallback;
+}
+
+// src/commands/login.ts
+async function loginCommand() {
+  intro2("Thyme CLI - Login");
+  const projectRoot = process.cwd();
+  const envPath = join4(projectRoot, ".env");
+  loadEnv(projectRoot);
+  info("To authenticate with Thyme Cloud:");
+  clack.log.message(
+    `  1. Visit ${pc.cyan("https://thyme.sh/settings/api-keys")}`
+  );
+  clack.log.message("  2. Generate a new API token");
+  clack.log.message("  3. Copy the token and paste it below");
+  clack.log.message("");
+  const token = await clack.password({
+    message: "Paste your API token:",
+    validate: (value) => {
+      if (!value) return "Token is required";
+      if (value.length < 10) return "Token seems too short";
+    }
+  });
+  if (clack.isCancel(token)) {
+    clack.cancel("Operation cancelled");
+    process.exit(0);
+  }
+  const spinner = clack.spinner();
+  spinner.start("Verifying token...");
+  try {
+    const apiUrl = getEnv("THYME_API_URL");
+    if (!apiUrl) {
+      spinner.stop("Configuration error");
+      error(
+        "THYME_API_URL is not set. Please set it to your Convex deployment URL (e.g., https://your-deployment.convex.cloud)"
+      );
+      process.exit(1);
+    }
+    const verifyResponse = await fetch(`${apiUrl}/api/auth/verify`, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${token}`
+      }
+    });
+    if (!verifyResponse.ok) {
+      spinner.stop("Token verification failed");
+      const errorText = await verifyResponse.text();
+      error(`Invalid token: ${errorText}`);
+      process.exit(1);
+    }
+    const verifyData = await verifyResponse.json();
+    spinner.stop("Token verified!");
+    const saveSpinner = clack.spinner();
+    saveSpinner.start("Saving token...");
+    let envContent = "";
+    if (existsSync4(envPath)) {
+      envContent = await readFile(envPath, "utf-8");
+    }
+    const tokenRegex = /^THYME_AUTH_TOKEN=.*$/m;
+    if (tokenRegex.test(envContent)) {
+      envContent = envContent.replace(tokenRegex, `THYME_AUTH_TOKEN=${token}`);
+      await writeFile2(envPath, envContent);
+    } else {
+      const newLine = envContent && !envContent.endsWith("\n") ? "\n" : "";
+      await appendFile(envPath, `${newLine}THYME_AUTH_TOKEN=${token}
+`);
+    }
+    saveSpinner.stop("Token saved successfully!");
+    clack.log.message("");
+    clack.log.success("Authenticated as:");
+    clack.log.message(
+      `  ${pc.cyan("User:")} ${verifyData.user.name || verifyData.user.email}`
+    );
+    clack.log.message(`  ${pc.cyan("Email:")} ${verifyData.user.email}`);
+    if (verifyData.organizations && verifyData.organizations.length > 0) {
+      clack.log.message("");
+      clack.log.message(`${pc.cyan("Organizations:")}`);
+      for (const org of verifyData.organizations) {
+        clack.log.message(`  \u2022 ${org.name} ${pc.dim(`(${org.role})`)}`);
+      }
+    }
+    outro2(`
+You can now upload tasks with ${pc.cyan("thyme upload")}`);
+  } catch (err) {
+    spinner.stop("Failed to verify token");
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+}
+
+// src/commands/new.ts
+import { existsSync as existsSync5 } from "fs";
+import { mkdir as mkdir2, writeFile as writeFile3 } from "fs/promises";
+import { join as join5 } from "path";
+async function newCommand(taskName) {
+  intro2("Thyme CLI - Create New Task");
+  const projectRoot = process.cwd();
+  if (!isThymeProject(projectRoot)) {
+    error("Not in a Thyme project. Run `thyme init` first.");
+    process.exit(1);
+  }
+  let finalTaskName = taskName;
+  if (!finalTaskName) {
+    const name = await clack.text({
+      message: "What is your task name?",
+      placeholder: "my-task",
+      validate: (value) => {
+        if (!value) return "Task name is required";
+        if (!/^[a-z0-9-]+$/.test(value))
+          return "Task name must be lowercase alphanumeric with hyphens";
+      }
+    });
+    if (clack.isCancel(name)) {
+      clack.cancel("Operation cancelled");
+      process.exit(0);
+    }
+    finalTaskName = name;
+  }
+  const taskPath = join5(projectRoot, "functions", finalTaskName);
+  if (existsSync5(taskPath)) {
+    error(`Task "${finalTaskName}" already exists`);
+    process.exit(1);
+  }
+  const spinner = clack.spinner();
+  spinner.start("Creating task...");
+  try {
+    await mkdir2(taskPath, { recursive: true });
+    const indexTs = `import { defineTask, z } from '@thyme-sh/sdk'
+import { encodeFunctionData } from 'viem'
+
+export default defineTask({
+	schema: z.object({
+		targetAddress: z.address(),
+	}),
+
+	async run(ctx) {
+		const { targetAddress } = ctx.args
+
+		// Your task logic here
+		console.log('Running task with address:', targetAddress)
+
+		// Example: Read from blockchain using the public client
+		// const balance = await ctx.client.getBalance({ address: targetAddress })
+		// const blockNumber = await ctx.client.getBlockNumber()
+		// const value = await ctx.client.readContract({
+		//   address: targetAddress,
+		//   abi: [...],
+		//   functionName: 'balanceOf',
+		//   args: [someAddress],
+		// })
+
+		// Example: Return calls to execute
+		return {
+			canExec: true,
+			calls: [
+				{
+					to: targetAddress,
+					data: '0x' as const,
+				},
+			],
+		}
+
+		// Example with encodeFunctionData:
+		// const abi = [...] as const
+		// return {
+		//   canExec: true,
+		//   calls: [
+		//     {
+		//       to: targetAddress,
+		//       data: encodeFunctionData({
+		//         abi,
+		//         functionName: 'transfer',
+		//         args: [recipientAddress, 1000n],
+		//       }),
+		//     },
+		//   ],
+		// }
+
+		// Or return false if conditions not met
+		// return {
+		//   canExec: false,
+		//   message: 'Conditions not met'
+		// }
+	},
+})
+`;
+    await writeFile3(join5(taskPath, "index.ts"), indexTs);
+    const args = {
+      targetAddress: "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"
+    };
+    await writeFile3(join5(taskPath, "args.json"), JSON.stringify(args, null, 2));
+    spinner.stop("Task created successfully!");
+    outro2(
+      `${pc.green("\u2713")} Task "${finalTaskName}" created!
+
+Next steps:
+  ${pc.cyan("Edit")} functions/${finalTaskName}/index.ts
+  ${pc.cyan("Update")} functions/${finalTaskName}/args.json
+  ${pc.cyan("thyme run")} ${finalTaskName}`
+    );
+  } catch (err) {
+    spinner.stop("Failed to create task");
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+}
+
+// src/commands/run.ts
+import { existsSync as existsSync6 } from "fs";
+import { readFile as readFile2 } from "fs/promises";
+import { http, createPublicClient, formatEther } from "viem";
+
+// src/deno/runner.ts
+import { spawn } from "child_process";
+import { dirname, resolve } from "path";
+async function runInDeno(taskPath, args, config2) {
+  const taskDir = dirname(resolve(taskPath));
+  const absoluteTaskPath = resolve(taskPath);
+  const denoFlags = ["run", "--no-prompt"];
+  denoFlags.push(`--allow-read=${taskDir}`);
+  if (config2.memory) {
+    denoFlags.push(`--v8-flags=--max-old-space-size=${config2.memory}`);
+  }
+  if (config2.network) {
+    denoFlags.push("--allow-net");
+  }
+  denoFlags.push("-");
+  const execScript = `
+import task from '${absoluteTaskPath}';
+import { createPublicClient, http } from 'npm:viem@2.21.54';
+
+// Create RPC request counter
+let rpcRequestCount = 0;
+
+// Wrap the http transport to count requests
+const countingHttp = (url) => {
+	const baseTransport = http(url);
+	return (config) => {
+		const transport = baseTransport(config);
+		return {
+			...transport,
+			request: async (params) => {
+				rpcRequestCount++;
+				return transport.request(params);
+			},
+		};
+	};
+};
+
+// Create public client for blockchain reads
+const client = createPublicClient({
+	transport: countingHttp(${config2.rpcUrl ? `'${config2.rpcUrl}'` : "undefined"}),
+});
+
+const context = {
+	args: ${JSON.stringify(args)},
+	client,
+};
+
+try {
+	// Track execution time and memory
+	const startTime = performance.now();
+	const startMemory = Deno.memoryUsage().heapUsed;
+	
+	const result = await task.run(context);
+	
+	const endTime = performance.now();
+	const endMemory = Deno.memoryUsage().heapUsed;
+	
+	const executionTime = endTime - startTime;
+	const memoryUsed = endMemory - startMemory;
+	
+	console.log('__THYME_RESULT__' + JSON.stringify(result));
+	console.log('__THYME_STATS__' + JSON.stringify({ executionTime, memoryUsed, rpcRequestCount }));
+} catch (error) {
+	console.error('Task execution error:', error instanceof Error ? error.message : String(error));
+	Deno.exit(1);
+}
+`;
+  return new Promise((resolve2) => {
+    const proc = spawn("deno", denoFlags, {
+      stdio: ["pipe", "pipe", "pipe"],
+      timeout: config2.timeout * 1e3,
+      cwd: taskDir
+    });
+    let stdout = "";
+    let stderr = "";
+    const logs = [];
+    proc.stdin?.write(execScript);
+    proc.stdin?.end();
+    proc.stdout?.on("data", (data) => {
+      stdout += data.toString();
+    });
+    proc.stderr?.on("data", (data) => {
+      stderr += data.toString();
+    });
+    proc.on("close", (code) => {
+      if (code !== 0) {
+        resolve2({
+          success: false,
+          logs,
+          error: stderr || `Process exited with code ${code}`
+        });
+        return;
+      }
+      try {
+        const lines = stdout.trim().split("\n");
+        let resultLine;
+        let statsLine;
+        for (const line of lines) {
+          if (line.startsWith("__THYME_RESULT__")) {
+            resultLine = line.substring("__THYME_RESULT__".length);
+          } else if (line.startsWith("__THYME_STATS__")) {
+            statsLine = line.substring("__THYME_STATS__".length);
+          } else if (line.trim()) {
+            logs.push(line.trim());
+          }
+        }
+        if (!resultLine) {
+          throw new Error("No result found in output");
+        }
+        const result = JSON.parse(resultLine);
+        const stats = statsLine ? JSON.parse(statsLine) : {
+          executionTime: void 0,
+          memoryUsed: void 0,
+          rpcRequestCount: void 0
+        };
+        resolve2({
+          success: true,
+          result,
+          logs,
+          executionTime: stats.executionTime,
+          memoryUsed: stats.memoryUsed,
+          rpcRequestCount: stats.rpcRequestCount
+        });
+      } catch (error2) {
+        resolve2({
+          success: false,
+          logs,
+          error: `Failed to parse result: ${error2 instanceof Error ? error2.message : String(error2)}`
+        });
+      }
+    });
+    proc.on("error", (error2) => {
+      resolve2({
+        success: false,
+        logs,
+        error: `Failed to spawn Deno: ${error2.message}`
+      });
+    });
+  });
+}
+async function checkDeno() {
+  return new Promise((resolve2) => {
+    const proc = spawn("deno", ["--version"], { stdio: "ignore" });
+    proc.on("close", (code) => resolve2(code === 0));
+    proc.on("error", () => resolve2(false));
+  });
+}
+
+// src/commands/run.ts
+async function runCommand(taskName, options = {}) {
+  intro2("Thyme CLI - Run Task");
+  const projectRoot = process.cwd();
+  loadEnv(projectRoot);
+  if (!isThymeProject(projectRoot)) {
+    error("Not in a Thyme project");
+    process.exit(1);
+  }
+  const hasDeno = await checkDeno();
+  if (!hasDeno) {
+    error("Deno is not installed. Please install Deno: https://deno.land/");
+    process.exit(1);
+  }
+  let finalTaskName = taskName;
+  if (!finalTaskName) {
+    const tasks = await discoverTasks(projectRoot);
+    if (tasks.length === 0) {
+      error("No tasks found. Create one with `thyme new`");
+      process.exit(1);
+    }
+    const selected = await clack.select({
+      message: "Select a task to run:",
+      options: tasks.map((task) => ({ value: task, label: task }))
+    });
+    if (clack.isCancel(selected)) {
+      clack.cancel("Operation cancelled");
+      process.exit(0);
+    }
+    finalTaskName = selected;
+  }
+  const taskPath = getTaskPath(projectRoot, finalTaskName);
+  const argsPath = getTaskArgsPath(projectRoot, finalTaskName);
+  if (!existsSync6(taskPath)) {
+    error(`Task "${finalTaskName}" not found`);
+    process.exit(1);
+  }
+  const config2 = {
+    memory: 128,
+    timeout: 30,
+    network: true,
+    rpcUrl: getEnv("RPC_URL")
+  };
+  let args = {};
+  if (existsSync6(argsPath)) {
+    try {
+      const argsData = await readFile2(argsPath, "utf-8");
+      args = JSON.parse(argsData);
+    } catch (err) {
+      warn(
+        `Failed to load args.json: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  const spinner = clack.spinner();
+  spinner.start("Executing task in Deno sandbox...");
+  const result = await runInDeno(taskPath, args, config2);
+  if (!result.success) {
+    spinner.stop("Task execution failed");
+    error(result.error ?? "Unknown error");
+    if (result.logs.length > 0) {
+      step("Task output:");
+      for (const taskLog of result.logs) {
+        log2(`  ${taskLog}`);
+      }
+    }
+    process.exit(1);
+  }
+  spinner.stop("Task executed successfully");
+  if (result.logs.length > 0) {
+    log2("");
+    step("Task output:");
+    for (const taskLog of result.logs) {
+      log2(`  ${taskLog}`);
+    }
+  }
+  if (!result.result) {
+    error("No result returned from task");
+    process.exit(1);
+  }
+  log2("");
+  if (result.result.canExec) {
+    info(
+      `${pc.green("\u2713")} Result: canExec = true (${result.result.calls.length} call(s))`
+    );
+    log2("");
+    step("Calls to execute:");
+    for (const call of result.result.calls) {
+      log2(`  ${pc.cyan("\u2192")} to: ${call.to}`);
+      log2(`     data: ${call.data.slice(0, 20)}...`);
+    }
+    if (options.simulate) {
+      log2("");
+      await simulateCalls(result.result.calls);
+    }
+  } else {
+    warn("Result: canExec = false");
+    info(`Message: ${result.result.message}`);
+  }
+  log2("");
+  if (result.executionTime !== void 0 || result.memoryUsed !== void 0 || result.rpcRequestCount !== void 0) {
+    step("Execution stats:");
+    if (result.executionTime !== void 0) {
+      log2(`  Duration: ${result.executionTime.toFixed(2)}ms`);
+    }
+    if (result.memoryUsed !== void 0) {
+      const memoryMB = (result.memoryUsed / 1024 / 1024).toFixed(2);
+      log2(`  Memory: ${memoryMB}MB`);
+    }
+    if (result.rpcRequestCount !== void 0) {
+      log2(`  RPC Requests: ${result.rpcRequestCount}`);
+    }
+  }
+  if (result.result?.canExec && !options.simulate) {
+    log2("");
+    info(
+      `${pc.dim("\u{1F4A1} Tip: Test calls on-chain with:")} ${pc.cyan(`thyme run ${finalTaskName} --simulate`)}`
+    );
+    outro2("");
+  } else {
+    outro2("");
+  }
+}
+async function simulateCalls(calls) {
+  const rpcUrl = getEnv("RPC_URL");
+  const account = getEnv("SIMULATE_ACCOUNT");
+  if (!rpcUrl || !account) {
+    warn("Simulation requires RPC_URL and SIMULATE_ACCOUNT in .env file");
+    return;
+  }
+  const spinner = clack.spinner();
+  spinner.start("Simulating on-chain...");
+  try {
+    const client = createPublicClient({
+      transport: http(rpcUrl)
+    });
+    const chainId = await client.getChainId();
+    const blockNumber = await client.getBlockNumber();
+    spinner.stop("Simulating on-chain...");
+    log2("");
+    info(`Chain ID: ${chainId}`);
+    info(`Block: ${blockNumber}`);
+    info(`Account: ${account}`);
+    const simulationSpinner = clack.spinner();
+    simulationSpinner.start("Running simulation...");
+    for (const call of calls) {
+      try {
+        await client.call({
+          account,
+          to: call.to,
+          data: call.data
+        });
+      } catch (err) {
+        simulationSpinner.stop("Simulation failed");
+        log2("");
+        error(
+          `Call to ${call.to} would revert: ${err instanceof Error ? err.message : String(err)}`
+        );
+        return;
+      }
+    }
+    const gasPrice = await client.getGasPrice();
+    simulationSpinner.stop("Simulation successful!");
+    log2("");
+    step("Simulation results:");
+    log2(`  ${pc.green("\u2713")} All calls would succeed`);
+    log2(`  Gas price: ${formatEther(gasPrice)} ETH`);
+  } catch (err) {
+    spinner.stop("Simulation failed");
+    log2("");
+    error(err instanceof Error ? err.message : String(err));
+  }
+}
+
+// src/commands/upload.ts
+import { existsSync as existsSync7 } from "fs";
+
+// src/utils/bundler.ts
+import { readFile as readFile3 } from "fs/promises";
+import { build } from "esbuild";
+async function bundleTask(taskPath) {
+  const source = await readFile3(taskPath, "utf-8");
+  const nodeBuiltins = [
+    "assert",
+    "buffer",
+    "child_process",
+    "cluster",
+    "crypto",
+    "dgram",
+    "dns",
+    "events",
+    "fs",
+    "http",
+    "http2",
+    "https",
+    "net",
+    "os",
+    "path",
+    "perf_hooks",
+    "process",
+    "querystring",
+    "readline",
+    "stream",
+    "string_decoder",
+    "timers",
+    "tls",
+    "tty",
+    "url",
+    "util",
+    "v8",
+    "vm",
+    "zlib",
+    // Node: prefix versions
+    "node:assert",
+    "node:buffer",
+    "node:child_process",
+    "node:cluster",
+    "node:crypto",
+    "node:dgram",
+    "node:dns",
+    "node:events",
+    "node:fs",
+    "node:http",
+    "node:http2",
+    "node:https",
+    "node:net",
+    "node:os",
+    "node:path",
+    "node:perf_hooks",
+    "node:process",
+    "node:querystring",
+    "node:readline",
+    "node:stream",
+    "node:string_decoder",
+    "node:timers",
+    "node:tls",
+    "node:tty",
+    "node:url",
+    "node:util",
+    "node:v8",
+    "node:vm",
+    "node:zlib"
+  ];
+  const result = await build({
+    entryPoints: [taskPath],
+    bundle: true,
+    format: "esm",
+    platform: "neutral",
+    target: "esnext",
+    write: false,
+    treeShaking: true,
+    minify: false,
+    // Keep readable for debugging
+    sourcemap: false,
+    external: nodeBuiltins,
+    // Don't bundle Node.js built-ins
+    logLevel: "silent"
+  });
+  if (result.outputFiles.length === 0) {
+    throw new Error("No output from bundler");
+  }
+  const bundle = result.outputFiles[0].text;
+  return {
+    source,
+    bundle
+  };
+}
+
+// src/utils/compress.ts
+import { compressTask as sdkCompressTask } from "@thyme-sh/sdk";
+function compressTask(source, bundle) {
+  const { zipBuffer, checksum } = sdkCompressTask(source, bundle);
+  return {
+    zipBuffer: Buffer.from(zipBuffer),
+    checksum
+  };
+}
+
+// src/utils/schema-extractor.ts
+function extractSchemaFromTask(taskCode) {
+  try {
+    const schemaExtractor = `
+      const { z } = require('zod');
+      const { zodToJsonSchema } = require('zod-to-json-schema');
+      
+      // Extended z with address validator
+      const zodExtended = {
+        ...z,
+        address: () => z.string().refine((val) => /^0x[a-fA-F0-9]{40}$/.test(val), {
+          message: 'Invalid Ethereum address',
+        }),
+      };
+      
+      // Mock defineTask to capture schema
+      let capturedSchema = null;
+      const defineTask = (definition) => {
+        if (definition.schema) {
+          capturedSchema = definition.schema;
+        }
+        return definition;
+      };
+      
+      // Mock viem exports
+      const encodeFunctionData = () => '0x';
+      
+      // Evaluate task code
+      ${taskCode}
+      
+      // Convert schema to JSON Schema
+      if (capturedSchema) {
+        const jsonSchema = zodToJsonSchema(capturedSchema, { target: 'openApi3' });
+        console.log(JSON.stringify(jsonSchema));
+      } else {
+        console.log('null');
+      }
+    `;
+    const schemaMatch = taskCode.match(/schema:\s*z\.object\(\{([^}]+)\}\)/);
+    if (!schemaMatch) {
+      return null;
+    }
+    const schemaContent = schemaMatch[1];
+    const fields = {};
+    const fieldMatches = schemaContent.matchAll(
+      /(\w+):\s*z\.(\w+)\(\)/g
+    );
+    for (const match of fieldMatches) {
+      const [, fieldName, fieldType] = match;
+      if (fieldName && fieldType) {
+        let jsonType = "string";
+        switch (fieldType) {
+          case "string":
+            jsonType = "string";
+            break;
+          case "number":
+            jsonType = "number";
+            break;
+          case "boolean":
+            jsonType = "boolean";
+            break;
+          case "address":
+            jsonType = "string";
+            break;
+          default:
+            jsonType = "string";
+        }
+        fields[fieldName] = {
+          type: jsonType,
+          ...fieldType === "address" && {
+            pattern: "^0x[a-fA-F0-9]{40}$",
+            description: "Ethereum address"
+          }
+        };
+      }
+    }
+    if (Object.keys(fields).length === 0) {
+      return null;
+    }
+    const jsonSchema = {
+      type: "object",
+      properties: fields,
+      required: Object.keys(fields)
+    };
+    return JSON.stringify(jsonSchema);
+  } catch (err) {
+    console.error("Error extracting schema:", err);
+    return null;
+  }
+}
+
+// src/commands/upload.ts
+async function uploadCommand(taskName, organizationId) {
+  intro2("Thyme CLI - Upload Task");
+  const projectRoot = process.cwd();
+  loadEnv(projectRoot);
+  if (!isThymeProject(projectRoot)) {
+    error("Not in a Thyme project");
+    process.exit(1);
+  }
+  const authToken = getEnv("THYME_AUTH_TOKEN");
+  if (!authToken) {
+    error("Not authenticated. Run `thyme login` first.");
+    process.exit(1);
+  }
+  const apiUrl = getEnv("THYME_API_URL");
+  if (!apiUrl) {
+    error(
+      "THYME_API_URL is not set. Please set it to your Convex deployment URL in .env"
+    );
+    process.exit(1);
+  }
+  let finalTaskName = taskName;
+  if (!finalTaskName) {
+    const tasks = await discoverTasks(projectRoot);
+    if (tasks.length === 0) {
+      error("No tasks found. Create one with `thyme new`");
+      process.exit(1);
+    }
+    const selected = await clack.select({
+      message: "Select a task to upload:",
+      options: tasks.map((task) => ({ value: task, label: task }))
+    });
+    if (clack.isCancel(selected)) {
+      clack.cancel("Operation cancelled");
+      process.exit(0);
+    }
+    finalTaskName = selected;
+  }
+  const orgSpinner = clack.spinner();
+  orgSpinner.start("Fetching organizations...");
+  let organizations = [];
+  try {
+    const verifyResponse = await fetch(`${apiUrl}/api/auth/verify`, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${authToken}`
+      }
+    });
+    if (!verifyResponse.ok) {
+      orgSpinner.stop("Failed to fetch organizations");
+      error("Failed to authenticate. Please run `thyme login` again.");
+      process.exit(1);
+    }
+    const verifyData = await verifyResponse.json();
+    organizations = verifyData.organizations || [];
+    orgSpinner.stop("Organizations loaded");
+  } catch (err) {
+    orgSpinner.stop("Failed to fetch organizations");
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+  if (organizations.length === 0) {
+    error("You are not a member of any organizations. Please create or join an organization first.");
+    process.exit(1);
+  }
+  let selectedOrgId = organizationId;
+  if (selectedOrgId) {
+    const orgExists = organizations.find((org) => org.id === selectedOrgId);
+    if (!orgExists) {
+      error(`Organization with ID "${selectedOrgId}" not found or you don't have access to it.`);
+      process.exit(1);
+    }
+  } else {
+    const selected = await clack.select({
+      message: "Select an organization to upload to:",
+      options: organizations.map((org) => ({
+        value: org.id,
+        label: `${org.name} ${pc.dim(`(${org.role})`)}`
+      }))
+    });
+    if (clack.isCancel(selected)) {
+      clack.cancel("Operation cancelled");
+      process.exit(0);
+    }
+    selectedOrgId = selected;
+  }
+  const taskPath = getTaskPath(projectRoot, finalTaskName);
+  if (!existsSync7(taskPath)) {
+    error(`Task "${finalTaskName}" not found`);
+    process.exit(1);
+  }
+  const spinner = clack.spinner();
+  spinner.start("Bundling task...");
+  try {
+    const { source, bundle } = await bundleTask(taskPath);
+    spinner.message("Extracting schema...");
+    const schema = extractSchemaFromTask(source);
+    spinner.message("Compressing files...");
+    const { zipBuffer, checksum } = compressTask(source, bundle);
+    spinner.message("Uploading to cloud...");
+    const formData = new FormData();
+    formData.append(
+      "data",
+      JSON.stringify({
+        organizationId: selectedOrgId,
+        checkSum: checksum,
+        schema: schema || void 0
+      })
+    );
+    formData.append("blob", new Blob([zipBuffer]), "task.zip");
+    const response = await fetch(`${apiUrl}/api/task/upload`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${authToken}`
+      },
+      body: formData
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(`Upload failed: ${errorText}`);
+    }
+    const result = await response.json();
+    spinner.stop("Task uploaded successfully!");
+    const selectedOrg = organizations.find((org) => org.id === selectedOrgId);
+    clack.log.message("");
+    clack.log.success("Upload details:");
+    clack.log.message(`  ${pc.dim("Task:")} ${pc.cyan(finalTaskName)}`);
+    clack.log.message(
+      `  ${pc.dim("Organization:")} ${pc.cyan(selectedOrg?.name || "Unknown")}`
+    );
+    clack.log.message(
+      `  ${pc.dim("Size:")} ${(zipBuffer.length / 1024).toFixed(2)} KB`
+    );
+    clack.log.message(`  ${pc.dim("Checksum:")} ${checksum.slice(0, 16)}...`);
+    if (result.taskId) {
+      clack.log.message(`  ${pc.dim("Task ID:")} ${pc.green(result.taskId)}`);
+    }
+    outro2(
+      `${pc.green("\u2713")} Task uploaded!
+
+Configure triggers in the dashboard: ${pc.cyan("https://thyme.sh/dashboard")}`
+    );
+  } catch (err) {
+    spinner.stop("Upload failed");
+    error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+  }
+}
+
+// src/index.ts
+var program = new Command();
+program.name("thyme").description("CLI for developing and deploying Thyme tasks").version("0.1.0");
+program.command("init").description("Initialize a new Thyme project").argument("[name]", "Project name").action(initCommand);
+program.command("new").description("Create a new task").argument("[name]", "Task name").action(newCommand);
+program.command("run").description("Run a task locally").argument("[task]", "Task name").option("--simulate", "Simulate on-chain execution").action((task, options) => runCommand(task, options));
+program.command("list").description("List all tasks").action(listCommand);
+program.command("login").description("Authenticate with Thyme Cloud").action(loginCommand);
+program.command("upload").description("Upload a task to Thyme Cloud").argument("[task]", "Task name").option("-o, --organization <id>", "Organization ID to upload to").action((task, options) => uploadCommand(task, options.organization));
+program.parse();
+//# sourceMappingURL=index.js.map