diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md
new file mode 100644
index 000000000..e46a48c8c
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@@ -0,0 +1,36 @@
+---
+title: 'Bug report'
+labels: user report
+---
+
+### 🐛 Bug Report
+
+<!-- Please answer these questions before submitting your issue. Thanks! -->
+
+#### What version of Wrangler are you using (`wrangler -V`)?
+
+<pre>
+$ wrangler -V
+
+</pre>
+
+#### Does this issue reproduce with the latest release?
+
+
+
+#### What environment are you using?
+* operating system:
+* rustc version:
+* node version:
+
+#### What did you do?
+
+<!--
+If possible, provide a recipe for reproducing the error.
+-->
+
+#### What did you expect to see?
+
+
+
+#### What did you see instead?
diff --git a/.github/ISSUE_TEMPLATE/feature_request.md b/.github/ISSUE_TEMPLATE/feature_request.md
new file mode 100644
index 000000000..fe5cdf79e
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/feature_request.md
@@ -0,0 +1,14 @@
+---
+title: 'Feature request'
+labels: user report
+---
+
+### 💡 Feature request
+
+<!-- Please answer these questions before submitting your issue. Thanks! -->
+
+#### Overview and problem statement
+Brief explanation of the requested feature, and a description of the problem it would solve.
+
+#### Basic example
+Include a basic code example of this new feature if possible. Omit this section if not applicable.
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 000000000..620bf3110
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,69 @@
+# Contributing
+
+Wrangler is an open source project because we believe that folks should have access, insight,
+and the opportunity to contirbute to their developer tools. Wrangler is also a product
+delivered by Cloudflare, so it's important to clarify how we think about issue triage and
+contributions.
+
+## People
+
+Wrangler is maintained by @ashleygwilliams, and her team, [Workers Developer Experience].
+
+[Workers Developer Experience]: https://github.com/orgs/cloudflare/teams/workers-devexp
+
+## Primary Issue Triage
+
+Within 3 days, any incoming issue should be triaged. Triage involves:
+
+- reading the issue and requesting any further information
+- always thank the user for submitting
+
+### Labelling
+
+- label all issues coming from non-team members with User Report
+- labelling the category of the issue: Feature, External Bug, Bug, Maintenance, Docs
+- optionally labelling a secondary category: Webpack, Routes, Workers Runtime, Refactor
+- labelling the status of the issue: Need More Info, Needs Repro, Needs Design, PR Welcome
+- optionally labelling other calls to action: Help Wanted, Question
+
+### Assignment
+
+- if the issue will require a large amount of back and forth between the reporter and the team
+    assign a single team member to manage the conversation
+
+## Product Issue Triage
+
+Once a week, the team meets to do Product Triage. This is where we assign work and update
+our plans for the milestones and releases.
+
+### Labelling
+
+- labelling the priority of the issue: Critical, Nice to Have, Low Priority
+- labelling the status of the issue: Needs Design, PR Welcome
+
+### Assignment and Milestones
+
+- assign all issues for the next two releases a milestone
+- assign all issues for the current milestone a person to take point
+
+### Pull Request Triage
+
+Within 3 days, all incoming Community PRs should be triaged. If a team member opens a PR it
+should be triaged immediately upon open by the PR author.
+
+### Labelling
+
+- All work-in-progress PRs should be labelled Work In Progress and the title should be
+    annotated [WIP] for easy scanning. No WIP PRs will be reviewed until the annotations
+    are removed.
+- All PRs that need to be reviewed should be labelled Needs Review until they have 
+    received all required reviews.
+- All PRs should be labelled with a changelog label: BREAKING, Feature, Bug, Maintenance, Docs
+
+### Merging
+
+- All PRs should be merged with a Merge Commit. We recommend that folks rebase into a small
+    number of task driven commits. This is enforced more heavily for team members than
+    community members. Be reasonable.
+- All PRs should be labelled with the current milestone before merging. If a PR for an issue
+    labelled with a different milestone is to be merged, update the issue milestone as well.
diff --git a/Cargo.lock b/Cargo.lock
index 273d9601f..b99c2c648 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1580,6 +1580,11 @@ dependencies = [
  "libc 0.2.58 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
+[[package]]
+name = "text_io"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
 [[package]]
 name = "textwrap"
 version = "0.11.0"
@@ -1948,6 +1953,7 @@ dependencies = [
  "reqwest 0.9.18 (registry+https://github.com/rust-lang/crates.io-index)",
  "serde 1.0.92 (registry+https://github.com/rust-lang/crates.io-index)",
  "serde_json 1.0.39 (registry+https://github.com/rust-lang/crates.io-index)",
+ "text_io 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)",
  "toml 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
  "uuid 0.7.4 (registry+https://github.com/rust-lang/crates.io-index)",
  "which 2.0.1 (registry+https://github.com/rust-lang/crates.io-index)",
@@ -2171,6 +2177,7 @@ dependencies = [
 "checksum termcolor 1.0.5 (registry+https://github.com/rust-lang/crates.io-index)" = "96d6098003bde162e4277c70665bd87c326f5a0c3f3fbfb285787fa482d54e6e"
 "checksum termion 1.5.3 (registry+https://github.com/rust-lang/crates.io-index)" = "6a8fb22f7cde82c8220e5aeacb3258ed7ce996142c77cba193f203515e26c330"
 "checksum termios 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "72b620c5ea021d75a735c943269bb07d30c9b77d6ac6b236bc8b5c496ef05625"
+"checksum text_io 0.1.7 (registry+https://github.com/rust-lang/crates.io-index)" = "9658b61ebd1d2a40c276ba2335890b9eb6550b67458a6fbce2022e58c3350a50"
 "checksum textwrap 0.11.0 (registry+https://github.com/rust-lang/crates.io-index)" = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060"
 "checksum thread_local 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)" = "c6b53e329000edc2b34dbe8545fd20e55a333362d0a321909685a19bd28c3f1b"
 "checksum time 0.1.42 (registry+https://github.com/rust-lang/crates.io-index)" = "db8dcfca086c1143c9270ac42a2bbd8a7ee477b78ac8e45b19abfb0cbede4b6f"
diff --git a/Cargo.toml b/Cargo.toml
index 9d0a730d5..c4195157b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -32,6 +32,7 @@ number_prefix = "0.3.0"
 flate2 = "1.0.7"
 base64 = "0.10.1"
 lazy_static = "1.3.0"
+text_io = "0.1.7"
 exitfailure = "0.5.1"
 
 [dev-dependencies]
diff --git a/README.md b/README.md
index a9e76979a..9a2dc163b 100644
--- a/README.md
+++ b/README.md
@@ -25,9 +25,9 @@ cargo install wrangler
 
 ## 🎙️ Commands
 
-  - ### 👯 `generate` 
+  - ### 👯 `generate`
     Scaffold a project, including boilerplate for a Rust library and a Cloudflare Worker.
-    You can pass a name and template to this command optionally. 
+    You can pass a name and template to this command optionally.
 
     ```
     wrangler generate <name> <template> --type=["webpack", "javascript", "rust"]
@@ -61,7 +61,7 @@ cargo install wrangler
     By default, `publish` will make your worker available at `<project-name>.<subdomain>.workers.dev`.
     To disable publishing to your workers.dev subdomain, set `private = true` in your `wrangler.toml`.
     This setting prevents the `publish` command from making your worker publicly available. To
-    explicitly enable deployment to `<project-name>.<subdomain>.workers.dev`, you can set `private = false`. 
+    explicitly enable deployment to `<project-name>.<subdomain>.workers.dev`, you can set `private = false`.
 
     To use this command, you'll need to have the following keys in your `wrangler.toml`:
 
@@ -143,6 +143,18 @@ There are two types of configuration that `wrangler` uses: global user and per p
         This key is optional if you are using a workers.dev subdomain and is only required for `publish --release`.
     - `webpack_config`: This is the path to the webpack configuration file for your worker. This is optional and
         defaults to `webpack.config.js`
+    - `[[kv-namespaces]]`: These specify any [Workers KV](https://workers.cloudflare.com/docs/reference/storage/) namespaces you want to access from
+        inside your Worker. Each namespace you include should have an entry in your wrangler.toml that includes:
+
+        - `binding`: the name you want to bind to in your script
+        - `id`: the namespace_id assigned to your kv namespace upon creation.
+            e.g. (per namespace):
+        ``` toml
+        [[kv-namespaces]]
+        binding = "FOO"
+        id = "0f2ac74b498b48028cb68387c421e279"
+        ```
+        Note: Creating your KV Namespaces should be handled either via the [api](https://workers.cloudflare.com/docs/reference/storage/writing-data/) or via your Cloudflare dashboard.
 
 ## ⚓ Installation
 
diff --git a/src/commands/build/wranglerjs/bundle.rs b/src/commands/build/wranglerjs/bundle.rs
index ddc95792e..86b47eb05 100644
--- a/src/commands/build/wranglerjs/bundle.rs
+++ b/src/commands/build/wranglerjs/bundle.rs
@@ -7,8 +7,6 @@ use std::io::prelude::*;
 use std::path::{Path, PathBuf};
 
 use crate::commands::build::wranglerjs::output::WranglerjsOutput;
-use crate::settings::binding::Binding;
-use crate::settings::metadata;
 #[cfg(test)]
 use crate::terminal::message;
 
@@ -51,21 +49,9 @@ impl Bundle {
 
         script_file.write_all(script.as_bytes())?;
 
-        let metadata = create_metadata(self).expect("could not create metadata");
-        let mut metadata_file = File::create(self.metadata_path())?;
-        metadata_file.write_all(metadata.as_bytes())?;
-
         Ok(())
     }
 
-    pub fn metadata_path(&self) -> String {
-        Path::new(&self.out)
-            .join("metadata.json".to_string())
-            .to_str()
-            .unwrap()
-            .to_string()
-    }
-
     pub fn wasm_path(&self) -> String {
         Path::new(&self.out)
             .join("module.wasm".to_string())
@@ -104,23 +90,6 @@ pub fn create_prologue() -> String {
     .to_string()
 }
 
-// This metadata describe the bindings on the Worker.
-fn create_metadata(bundle: &Bundle) -> Result<String, serde_json::error::Error> {
-    let mut bindings = vec![];
-
-    if bundle.has_wasm() {
-        bindings.push(Binding::new_wasm_module(
-            bundle.get_wasm_binding(),
-            bundle.get_wasm_binding(),
-        ));
-    }
-
-    serde_json::to_string(&metadata::Metadata {
-        body_part: "script".to_string(),
-        bindings,
-    })
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -136,27 +105,6 @@ mod tests {
         dir.to_str().unwrap().to_string()
     }
 
-    #[test]
-    fn it_writes_the_bundle_metadata() {
-        let out = create_temp_dir("it_writes_the_bundle_metadata");
-        let wranglerjs_output = WranglerjsOutput {
-            errors: vec![],
-            script: "".to_string(),
-
-            wasm: None,
-        };
-        let bundle = Bundle::new_at(out.clone());
-
-        bundle.write(&wranglerjs_output).unwrap();
-        assert!(Path::new(&bundle.metadata_path()).exists());
-        let contents =
-            fs::read_to_string(&bundle.metadata_path()).expect("could not read metadata");
-
-        assert_eq!(contents, r#"{"body_part":"script","bindings":[]}"#);
-
-        cleanup(out);
-    }
-
     #[test]
     fn it_writes_the_bundle_script() {
         let out = create_temp_dir("it_writes_the_bundle_script");
@@ -191,29 +139,6 @@ mod tests {
         cleanup(out);
     }
 
-    #[test]
-    fn it_writes_the_bundle_wasm_metadata() {
-        let out = create_temp_dir("it_writes_the_bundle_wasm_metadata");
-        let wranglerjs_output = WranglerjsOutput {
-            errors: vec![],
-            script: "".to_string(),
-            wasm: Some("abc".to_string()),
-        };
-        let bundle = Bundle::new_at(out.clone());
-
-        bundle.write(&wranglerjs_output).unwrap();
-        assert!(Path::new(&bundle.metadata_path()).exists());
-        let contents =
-            fs::read_to_string(&bundle.metadata_path()).expect("could not read metadata");
-
-        assert_eq!(
-            contents,
-            r#"{"body_part":"script","bindings":[{"type":"wasm_module","name":"wasmprogram","part":"wasmprogram"}]}"#
-        );
-
-        cleanup(out);
-    }
-
     #[test]
     fn it_has_errors() {
         let wranglerjs_output = WranglerjsOutput {
diff --git a/src/commands/build/wranglerjs/output.rs b/src/commands/build/wranglerjs/output.rs
index fd4dd8cb9..ec76c2967 100644
--- a/src/commands/build/wranglerjs/output.rs
+++ b/src/commands/build/wranglerjs/output.rs
@@ -43,6 +43,7 @@ impl WranglerjsOutput {
     fn project_size_message(compressed_size: u64) -> String {
         const MAX_PROJECT_SIZE: u64 = 1 << 20; // 1 MiB
         const WARN_THRESHOLD: u64 = MAX_PROJECT_SIZE - 81_920; //Warn when less than 80 KiB left to grow, ~92% usage
+        const MAX_BEFORE_WARN: u64 = WARN_THRESHOLD - 1;
 
         let bytes_left = MAX_PROJECT_SIZE.checked_sub(compressed_size);
 
@@ -63,7 +64,7 @@ impl WranglerjsOutput {
 
         match compressed_size {
             WARN_THRESHOLD...MAX_PROJECT_SIZE => format!("{}. {2} Your built project is {} away from reaching the 1MiB size limit. {2}", human_size, human_leftover.expect("failed to get leftover bytes"), emoji::WARN),
-            0...WARN_THRESHOLD => format!("{}.", human_size),
+            0...MAX_BEFORE_WARN => format!("{}.", human_size),
             _ => format!("{}. {1} Your built project has grown past the 1MiB size limit and may fail to deploy. {1}", human_size, emoji::WARN)
         }
     }
diff --git a/src/commands/config.rs b/src/commands/config.rs
index 2b8a82f51..2729acc14 100644
--- a/src/commands/config.rs
+++ b/src/commands/config.rs
@@ -1,9 +1,21 @@
 use crate::terminal::message;
 use std::fs;
-use std::path::Path;
+use std::fs::File;
+#[cfg(not(target_os = "windows"))]
+use std::os::unix::fs::PermissionsExt;
+use std::path::PathBuf;
 
-use crate::emoji;
-use crate::settings::global_user::GlobalUser;
+use crate::settings::global_user::{get_global_config_dir, GlobalUser};
+
+// set the permissions on the dir, we want to avoid that other user reads to
+// file
+#[cfg(not(target_os = "windows"))]
+pub fn set_file_mode(file: &PathBuf) {
+    File::open(&file)
+        .unwrap()
+        .set_permissions(PermissionsExt::from_mode(0o600))
+        .expect("could not set permissions on file");
+}
 
 pub fn global_config(email: &str, api_key: &str) -> Result<(), failure::Error> {
     let s = GlobalUser {
@@ -13,19 +25,16 @@ pub fn global_config(email: &str, api_key: &str) -> Result<(), failure::Error> {
 
     let toml = toml::to_string(&s)?;
 
-    let config_dir = Path::new(&dirs::home_dir().unwrap_or_else(|| {
-        panic!(
-            "{0} could not determine home directory. {0}",
-            emoji::CONSTRUCTION
-        )
-    }))
-    .join(".wrangler")
-    .join("config");
+    let config_dir = get_global_config_dir().expect("could not find global config directory");
     fs::create_dir_all(&config_dir)?;
 
     let config_file = config_dir.join("default.toml");
     fs::write(&config_file, &toml)?;
 
+    // set permissions on the file
+    #[cfg(not(target_os = "windows"))]
+    set_file_mode(&config_file);
+
     message::success(&format!(
         "Successfully configured. You can find your configuration file at: {}",
         &config_file.to_string_lossy()
diff --git a/src/commands/publish/mod.rs b/src/commands/publish/mod.rs
index 5e9e78cee..6dab662b9 100644
--- a/src/commands/publish/mod.rs
+++ b/src/commands/publish/mod.rs
@@ -2,16 +2,14 @@ mod krate;
 pub mod package;
 pub mod preview;
 mod route;
-mod script_upload_form;
+mod upload_form;
 
 use package::Package;
 use route::Route;
-use script_upload_form::build_script_upload_form;
+use upload_form::build_script_upload_form;
 
 use log::info;
 
-use std::collections::HashMap;
-
 use crate::commands;
 use crate::commands::subdomain::Subdomain;
 use crate::http;
@@ -24,7 +22,6 @@ pub fn publish(user: &GlobalUser, project: &Project, release: bool) -> Result<()
 
     validate_project(project, release)?;
     commands::build(&project)?;
-    create_kv_namespaces(user, &project)?;
     publish_script(&user, &project, release)?;
     if release {
         info!("release mode detected, making a route...");
@@ -41,43 +38,6 @@ pub fn publish(user: &GlobalUser, project: &Project, release: bool) -> Result<()
     Ok(())
 }
 
-pub fn create_kv_namespaces(user: &GlobalUser, project: &Project) -> Result<(), failure::Error> {
-    let kv_addr = format!(
-        "https://api.cloudflare.com/client/v4/accounts/{}/storage/kv/namespaces",
-        project.account_id,
-    );
-
-    let client = http::auth_client(user);
-
-    if let Some(namespaces) = &project.kv_namespaces {
-        for namespace in namespaces {
-            info!("Attempting to create namespace '{}'", namespace);
-
-            let mut map = HashMap::new();
-            map.insert("title", namespace);
-
-            let request = client.post(&kv_addr).json(&map).send();
-
-            if let Err(error) = request {
-                // A 400 is returned if the account already owns a namespace with this title.
-                //
-                // https://api.cloudflare.com/#workers-kv-namespace-create-a-namespace
-                match error.status() {
-                    Some(code) if code == 400 => {
-                        info!("Namespace '{}' already exists, continuing.", namespace)
-                    }
-                    _ => {
-                        info!("Error when creating namespace '{}'", namespace);
-                        failure::bail!("⛔ Something went wrong! Error: {}", error)
-                    }
-                }
-            }
-            info!("Namespace '{}' exists now", namespace)
-        }
-    }
-    Ok(())
-}
-
 fn publish_script(
     user: &GlobalUser,
     project: &Project,
@@ -166,6 +126,21 @@ fn validate_project(project: &Project, release: bool) -> Result<(), failure::Err
         missing_fields.push("name")
     };
 
+    match &project.kv_namespaces {
+        Some(kv_namespaces) => {
+            for kv in kv_namespaces {
+                if kv.binding.is_empty() {
+                    missing_fields.push("kv-namespace binding")
+                }
+
+                if kv.id.is_empty() {
+                    missing_fields.push("kv-namespace id")
+                }
+            }
+        }
+        None => {}
+    }
+
     let destination = if release {
         //check required fields for release
         if project
diff --git a/src/commands/publish/preview/mod.rs b/src/commands/publish/preview/mod.rs
index 6b14d6bb8..72ec8c5dd 100644
--- a/src/commands/publish/preview/mod.rs
+++ b/src/commands/publish/preview/mod.rs
@@ -34,7 +34,8 @@ pub fn preview(
     let res = client
         .post(create_address)
         .multipart(script_upload_form)
-        .send();
+        .send()?
+        .error_for_status();
 
     let p: Preview = serde_json::from_str(&res?.text()?)?;
 
diff --git a/src/commands/publish/script_upload_form.rs b/src/commands/publish/script_upload_form.rs
deleted file mode 100644
index b9e5d200a..000000000
--- a/src/commands/publish/script_upload_form.rs
+++ /dev/null
@@ -1,112 +0,0 @@
-use log::info;
-
-use reqwest::multipart::{Form, Part};
-use std::fs;
-use std::path::Path;
-
-use crate::commands::build::wranglerjs::Bundle;
-use crate::settings::project::{Project, ProjectType};
-
-use super::{krate, Package};
-
-pub fn build_script_upload_form(project: &Project) -> Result<Form, failure::Error> {
-    let project_type = &project.project_type;
-    let script_upload_form = match project_type {
-        ProjectType::Rust => {
-            info!("Rust project detected. Publishing...");
-            build_multipart_script()?
-        }
-        ProjectType::JavaScript => {
-            info!("JavaScript project detected. Publishing...");
-            build_js_script()?
-        }
-        ProjectType::Webpack => {
-            info!("Webpack project detected. Publishing...");
-            build_webpack_form()?
-        }
-    };
-
-    Ok(script_upload_form)
-}
-
-fn build_js_script() -> Result<Form, failure::Error> {
-    let package = Package::new("./")?;
-    let script_path = package.main()?;
-    let metadata_json = r#"{"body_part":"script","bindings":[]}"#;
-
-    let metadata = Part::text(metadata_json)
-        .file_name("metadata.json")
-        .mime_str("application/json")?;
-
-    Ok(Form::new()
-        .file("script", &script_path)
-        .unwrap_or_else(|_| panic!("{} not found. Did you rename your js files?", &script_path))
-        .part("metadata", metadata))
-}
-
-fn build_multipart_script() -> Result<Form, failure::Error> {
-    let name = krate::Krate::new("./")?.name.replace("-", "_");
-    build_generated_dir()?;
-    concat_js(&name)?;
-
-    let metadata_path = "./worker/metadata_wasm.json";
-    let wasm_path = &format!("./pkg/{}_bg.wasm", name);
-    let script_path = "./worker/generated/script.js";
-
-    Ok(Form::new()
-        .file("metadata", metadata_path)
-        .unwrap_or_else(|_| panic!("{} not found. Did you delete it?", metadata_path))
-        .file("wasmprogram", wasm_path)
-        .unwrap_or_else(|_| panic!("{} not found. Have you run wrangler build?", wasm_path))
-        .file("script", script_path)
-        .unwrap_or_else(|_| panic!("{} not found. Did you rename your js files?", script_path)))
-}
-
-fn build_generated_dir() -> Result<(), failure::Error> {
-    let dir = "./worker/generated";
-    if !Path::new(dir).is_dir() {
-        fs::create_dir("./worker/generated")?;
-    }
-
-    Ok(())
-}
-
-fn concat_js(name: &str) -> Result<(), failure::Error> {
-    let bindgen_js_path = format!("./pkg/{}.js", name);
-    let bindgen_js: String = fs::read_to_string(bindgen_js_path)?.parse()?;
-
-    let worker_js: String = fs::read_to_string("./worker/worker.js")?.parse()?;
-    let js = format!("{} {}", bindgen_js, worker_js);
-
-    fs::write("./worker/generated/script.js", js.as_bytes())?;
-    Ok(())
-}
-
-fn build_webpack_form() -> Result<Form, failure::Error> {
-    // FIXME(sven): shouldn't new
-    let bundle = Bundle::new();
-
-    let form = Form::new()
-        .file("metadata", bundle.metadata_path())
-        .unwrap_or_else(|_| panic!("{} not found. Did you delete it?", bundle.metadata_path()))
-        .file("script", bundle.script_path())
-        .unwrap_or_else(|_| {
-            panic!(
-                "{} not found. Did you rename your js files?",
-                bundle.script_path()
-            )
-        });
-
-    if bundle.has_wasm() {
-        Ok(form
-            .file(bundle.get_wasm_binding(), bundle.wasm_path())
-            .unwrap_or_else(|_| {
-                panic!(
-                    "{} not found. Have you run wrangler build?",
-                    bundle.wasm_path()
-                )
-            }))
-    } else {
-        Ok(form)
-    }
-}
diff --git a/src/commands/publish/upload_form/mod.rs b/src/commands/publish/upload_form/mod.rs
new file mode 100644
index 000000000..eae19364d
--- /dev/null
+++ b/src/commands/publish/upload_form/mod.rs
@@ -0,0 +1,136 @@
+mod project_assets;
+mod wasm_module;
+
+use log::info;
+
+use reqwest::multipart::{Form, Part};
+use std::fs;
+use std::path::Path;
+
+use crate::commands::build::wranglerjs;
+use crate::settings::binding;
+use crate::settings::metadata::Metadata;
+use crate::settings::project::kv_namespace;
+use crate::settings::project::{Project, ProjectType};
+
+use project_assets::ProjectAssets;
+use wasm_module::WasmModule;
+
+use super::{krate, Package};
+
+pub fn build_script_upload_form(project: &Project) -> Result<Form, failure::Error> {
+    let project_type = &project.project_type;
+    let kv_namespaces = project.kv_namespaces();
+    match project_type {
+        ProjectType::Rust => {
+            info!("Rust project detected. Publishing...");
+            let name = krate::Krate::new("./")?.name.replace("-", "_");
+            // TODO: move into build?
+            build_generated_dir()?;
+            concat_js(&name)?;
+
+            let path = format!("./pkg/{}_bg.wasm", name).to_string();
+            let binding = "wasm".to_string();
+            let wasm_module = WasmModule::new(path, binding)?;
+
+            let script_path = "./worker/generated/script.js".to_string();
+
+            let assets = ProjectAssets::new(script_path, vec![wasm_module], kv_namespaces)?;
+
+            build_form(&assets)
+        }
+        ProjectType::JavaScript => {
+            info!("JavaScript project detected. Publishing...");
+            let package = Package::new("./")?;
+
+            let script_path = package.main()?;
+
+            let assets = ProjectAssets::new(script_path, Vec::new(), kv_namespaces)?;
+
+            build_form(&assets)
+        }
+        ProjectType::Webpack => {
+            info!("Webpack project detected. Publishing...");
+            // FIXME(sven): shouldn't new
+            let bundle = wranglerjs::Bundle::new();
+
+            let script_path = bundle.script_path();
+
+            let mut wasm_modules = Vec::new();
+
+            if bundle.has_wasm() {
+                let path = bundle.wasm_path();
+                let binding = bundle.get_wasm_binding();
+                let wasm_module = WasmModule::new(path, binding)?;
+                wasm_modules.push(wasm_module)
+            }
+
+            let assets = ProjectAssets::new(script_path, wasm_modules, kv_namespaces)?;
+
+            build_form(&assets)
+        }
+    }
+}
+
+fn build_form(assets: &ProjectAssets) -> Result<Form, failure::Error> {
+    let mut form = Form::new();
+
+    // The preview service in particular streams the request form, and requires that the
+    // "metadata" part be set first, so this order is important.
+    form = add_metadata(form, assets)?;
+    form = add_files(form, assets)?;
+
+    info!("{:?}", &form);
+
+    Ok(form)
+}
+
+fn add_files(mut form: Form, assets: &ProjectAssets) -> Result<Form, failure::Error> {
+    form = form.file(assets.script_name(), assets.script_path())?;
+
+    for wasm_module in &assets.wasm_modules {
+        form = form.file(wasm_module.filename(), wasm_module.path())?;
+    }
+
+    Ok(form)
+}
+
+fn add_metadata(mut form: Form, assets: &ProjectAssets) -> Result<Form, failure::Error> {
+    let metadata_json = serde_json::json!(&Metadata {
+        body_part: assets.script_name(),
+        bindings: assets.bindings(),
+    });
+
+    let metadata = Part::text((metadata_json).to_string())
+        .file_name("metadata.json")
+        .mime_str("application/json")?;
+
+    form = form.part("metadata", metadata);
+
+    Ok(form)
+}
+
+fn filename_from_path(path: &str) -> Option<String> {
+    let path = Path::new(path);
+    path.file_stem()?.to_str().map(|s| s.to_string())
+}
+
+fn build_generated_dir() -> Result<(), failure::Error> {
+    let dir = "./worker/generated";
+    if !Path::new(dir).is_dir() {
+        fs::create_dir("./worker/generated")?;
+    }
+
+    Ok(())
+}
+
+fn concat_js(name: &str) -> Result<(), failure::Error> {
+    let bindgen_js_path = format!("./pkg/{}.js", name);
+    let bindgen_js: String = fs::read_to_string(bindgen_js_path)?.parse()?;
+
+    let worker_js: String = fs::read_to_string("./worker/worker.js")?.parse()?;
+    let js = format!("{} {}", bindgen_js, worker_js);
+
+    fs::write("./worker/generated/script.js", js.as_bytes())?;
+    Ok(())
+}
diff --git a/src/commands/publish/upload_form/project_assets.rs b/src/commands/publish/upload_form/project_assets.rs
new file mode 100644
index 000000000..a4f3e5171
--- /dev/null
+++ b/src/commands/publish/upload_form/project_assets.rs
@@ -0,0 +1,55 @@
+use failure::format_err;
+
+use super::binding::Binding;
+use super::filename_from_path;
+use super::kv_namespace::KvNamespace;
+use super::wasm_module::WasmModule;
+
+#[derive(Debug)]
+pub struct ProjectAssets {
+    script_name: String,
+    script_path: String,
+    pub wasm_modules: Vec<WasmModule>,
+    pub kv_namespaces: Vec<KvNamespace>,
+}
+
+impl ProjectAssets {
+    pub fn new(
+        script_path: String,
+        wasm_modules: Vec<WasmModule>,
+        kv_namespaces: Vec<KvNamespace>,
+    ) -> Result<Self, failure::Error> {
+        let script_name = filename_from_path(&script_path)
+            .ok_or_else(|| format_err!("filename should not be empty: {}", script_path))?;
+
+        Ok(Self {
+            script_name,
+            script_path,
+            wasm_modules,
+            kv_namespaces,
+        })
+    }
+
+    pub fn bindings(&self) -> Vec<Binding> {
+        let mut bindings = Vec::new();
+
+        for wm in &self.wasm_modules {
+            let binding = wm.binding();
+            bindings.push(binding);
+        }
+        for kv in &self.kv_namespaces {
+            let binding = kv.binding();
+            bindings.push(binding);
+        }
+
+        bindings
+    }
+
+    pub fn script_name(&self) -> String {
+        self.script_name.to_string()
+    }
+
+    pub fn script_path(&self) -> String {
+        self.script_path.to_string()
+    }
+}
diff --git a/src/commands/publish/upload_form/wasm_module.rs b/src/commands/publish/upload_form/wasm_module.rs
new file mode 100644
index 000000000..6cc975545
--- /dev/null
+++ b/src/commands/publish/upload_form/wasm_module.rs
@@ -0,0 +1,41 @@
+use failure::format_err;
+
+use super::binding::Binding;
+use super::filename_from_path;
+
+#[derive(Debug)]
+pub struct WasmModule {
+    path: String,
+    filename: String,
+    binding: String,
+}
+
+impl WasmModule {
+    pub fn new(path: String, binding: String) -> Result<Self, failure::Error> {
+        let filename = filename_from_path(&path)
+            .ok_or_else(|| format_err!("filename should not be empty: {}", path))?;
+
+        Ok(Self {
+            filename,
+            path,
+            binding,
+        })
+    }
+
+    // `name` corresponds to the binding used in the worker js
+    // `part` corresponds to the name given to the file in the upload form
+    pub fn binding(&self) -> Binding {
+        let name = &self.binding;
+        let part = &self.filename;
+
+        Binding::new_wasm_module(name, part)
+    }
+
+    pub fn path(&self) -> String {
+        self.path.to_string()
+    }
+
+    pub fn filename(&self) -> String {
+        self.filename.to_string()
+    }
+}
diff --git a/src/main.rs b/src/main.rs
index e327d226f..8e0e39ce9 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,5 +1,8 @@
 #![allow(clippy::redundant_closure)]
 
+#[macro_use]
+extern crate text_io;
+
 use std::env;
 use std::str::FromStr;
 
@@ -127,19 +130,7 @@ fn run() -> Result<(), failure::Error> {
                 .about(&*format!(
                     "{} Setup wrangler with your Cloudflare account",
                     emoji::SLEUTH
-                ))
-                .arg(
-                    Arg::with_name("email")
-                        .help("the email address associated with your Cloudflare account")
-                        .index(1)
-                        .required(true),
-                )
-                .arg(
-                    Arg::with_name("api-key")
-                        .help("your Cloudflare API key")
-                        .index(2)
-                        .required(true),
-                ),
+                )),
         )
         .subcommand(
             SubCommand::with_name("subdomain")
@@ -160,15 +151,13 @@ fn run() -> Result<(), failure::Error> {
         )))
         .get_matches();
 
-    if let Some(matches) = matches.subcommand_matches("config") {
-        let email = matches
-            .value_of("email")
-            .expect("An email address must be provided.");
-        let api_key = matches
-            .value_of("api-key")
-            .expect("An API key must be provided.");
+    if let Some(_matches) = matches.subcommand_matches("config") {
+        println!("Enter email: ");
+        let email: String = read!("{}\n");
+        println!("Enter api key: ");
+        let api_key: String = read!("{}\n");
 
-        commands::global_config(email, api_key)?;
+        commands::global_config(&email, &api_key)?;
     } else if let Some(matches) = matches.subcommand_matches("generate") {
         let name = matches.value_of("name").unwrap_or("worker");
         let project_type = match matches.value_of("type") {
diff --git a/src/settings/binding.rs b/src/settings/binding.rs
index e036559cf..45dba32bd 100644
--- a/src/settings/binding.rs
+++ b/src/settings/binding.rs
@@ -3,12 +3,21 @@ use serde::Serialize;
 #[derive(Serialize, Debug)]
 #[serde(tag = "type")]
 pub enum Binding {
-    #[allow(non_camel_case_types)]
-    wasm_module { name: String, part: String },
+    #[serde(rename = "wasm_module")]
+    WasmModule { name: String, part: String },
+    #[serde(rename = "kv_namespace")]
+    KvNamespace { name: String, namespace_id: String },
 }
 
 impl Binding {
-    pub fn new_wasm_module(name: String, part: String) -> Binding {
-        Binding::wasm_module { name, part }
+    pub fn new_wasm_module(name: &str, part: &str) -> Binding {
+        Binding::WasmModule {
+            name: name.to_string(),
+            part: part.to_string(),
+        }
+    }
+
+    pub fn new_kv_namespace(name: String, namespace_id: String) -> Binding {
+        Binding::KvNamespace { name, namespace_id }
     }
 }
diff --git a/src/settings/global_user.rs b/src/settings/global_user.rs
index 3383a586c..ba84a4671 100644
--- a/src/settings/global_user.rs
+++ b/src/settings/global_user.rs
@@ -1,8 +1,12 @@
-use crate::terminal::emoji;
+use std::env;
+use std::path::{Path, PathBuf};
 
-use config::{Config, Environment, File};
+use log::info;
 use serde::{Deserialize, Serialize};
 
+use crate::terminal::emoji;
+use config::{Config, Environment, File};
+
 #[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct GlobalUser {
     pub email: String,
@@ -18,15 +22,25 @@ impl GlobalUser {
 fn get_global_config() -> Result<GlobalUser, failure::Error> {
     let mut s = Config::new();
 
-    let config_path = dirs::home_dir()
-        .expect("oops no home dir")
-        .join(".wrangler/config/default");
+    let config_path = get_global_config_dir()
+        .expect("could not find global config directory")
+        .join("default.toml");
     let config_str = config_path
         .to_str()
         .expect("global config path should be a string");
-    s.merge(File::with_name(config_str))?;
 
-    // Eg.. `CF_ACCOUNT_AUTH_KEY=farts` would set the `account_auth_key` key
+    // Skip reading global config if non existent
+    // because envs might be provided
+    if config_path.exists() {
+        info!(
+            "Config path exists. Reading from config file, {}",
+            config_str
+        );
+        s.merge(File::with_name(config_str))?;
+    }
+
+    // Eg.. `CF_API_KEY=farts` would set the `account_auth_key` key
+    // envs are: CF_API_KEY and CF_EMAIL
     s.merge(Environment::with_prefix("CF"))?;
 
     let global_user: Result<GlobalUser, config::ConfigError> = s.try_into();
@@ -42,3 +56,18 @@ fn get_global_config() -> Result<GlobalUser, failure::Error> {
         }
     }
 }
+
+pub fn get_global_config_dir() -> Result<PathBuf, failure::Error> {
+    let home_dir = if let Ok(value) = env::var("WRANGLER_HOME") {
+        info!("Using WRANGLER_HOME: {}", value);
+        Path::new(&value).to_path_buf()
+    } else {
+        info!("No WRANGLER_HOME detected");
+        dirs::home_dir()
+            .expect("oops no home dir")
+            .join(".wrangler")
+    };
+    let global_config_dir = home_dir.join("config");
+    info!("Using global config dir: {:?}", global_config_dir);
+    Ok(global_config_dir)
+}
diff --git a/src/settings/project/kv_namespace.rs b/src/settings/project/kv_namespace.rs
new file mode 100644
index 000000000..67051651a
--- /dev/null
+++ b/src/settings/project/kv_namespace.rs
@@ -0,0 +1,22 @@
+use crate::settings::binding::Binding;
+use std::fmt;
+
+use serde::{Deserialize, Serialize};
+
+#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
+pub struct KvNamespace {
+    pub id: String,
+    pub binding: String,
+}
+
+impl fmt::Display for KvNamespace {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "id: {}, binding: {}", self.id, self.binding)
+    }
+}
+
+impl KvNamespace {
+    pub fn binding(&self) -> Binding {
+        Binding::new_kv_namespace(self.binding.clone(), self.id.clone())
+    }
+}
diff --git a/src/settings/project.rs b/src/settings/project/mod.rs
similarity index 61%
rename from src/settings/project.rs
rename to src/settings/project/mod.rs
index 654816ade..9ef0e589b 100644
--- a/src/settings/project.rs
+++ b/src/settings/project/mod.rs
@@ -1,10 +1,15 @@
+pub mod kv_namespace;
+mod project_type;
+
+pub use kv_namespace::KvNamespace;
+pub use project_type::ProjectType;
+
 use crate::terminal::emoji;
+use crate::terminal::message;
 
 use std::collections::HashMap;
-use std::fmt;
 use std::fs;
 use std::path::{Path, PathBuf};
-use std::str::FromStr;
 
 use log::info;
 
@@ -23,45 +28,7 @@ pub struct Project {
     pub route: Option<String>,
     pub routes: Option<HashMap<String, String>>,
     #[serde(rename = "kv-namespaces")]
-    pub kv_namespaces: Option<Vec<String>>,
-}
-
-#[derive(Clone, Debug, Deserialize, Serialize)]
-#[serde(rename_all = "lowercase")]
-pub enum ProjectType {
-    JavaScript,
-    Rust,
-    Webpack,
-}
-
-impl Default for ProjectType {
-    fn default() -> Self {
-        ProjectType::Webpack
-    }
-}
-
-impl fmt::Display for ProjectType {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let printable = match *self {
-            ProjectType::JavaScript => "js",
-            ProjectType::Rust => "rust",
-            ProjectType::Webpack => "webpack",
-        };
-        write!(f, "{}", printable)
-    }
-}
-
-impl FromStr for ProjectType {
-    type Err = failure::Error;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s {
-            "javascript" => Ok(ProjectType::JavaScript),
-            "rust" => Ok(ProjectType::Rust),
-            "webpack" => Ok(ProjectType::Webpack),
-            _ => failure::bail!("{} is not a valid wrangler project type!", s),
-        }
-    }
+    pub kv_namespaces: Option<Vec<KvNamespace>>,
 }
 
 impl Project {
@@ -96,14 +63,19 @@ impl Project {
     }
 
     pub fn new() -> Result<Self, failure::Error> {
-        get_project_config()
+        let config_path = Path::new("./wrangler.toml");
+
+        get_project_config(config_path)
+    }
+
+    pub fn kv_namespaces(&self) -> Vec<KvNamespace> {
+        self.kv_namespaces.clone().unwrap_or_else(Vec::new)
     }
 }
 
-pub fn get_project_config() -> Result<Project, failure::Error> {
+fn get_project_config(config_path: &Path) -> Result<Project, failure::Error> {
     let mut s = Config::new();
 
-    let config_path = Path::new("./wrangler.toml");
     let config_str = config_path
         .to_str()
         .expect("project config path should be a string");
@@ -112,6 +84,32 @@ pub fn get_project_config() -> Result<Project, failure::Error> {
     // Eg.. `CF_ACCOUNT_AUTH_KEY=farts` would set the `account_auth_key` key
     s.merge(Environment::with_prefix("CF"))?;
 
+    // check for pre 1.1.0 KV namespace format
+    let kv_namespaces: Result<Vec<config::Value>, config::ConfigError> = s.get("kv-namespaces");
+
+    if let Ok(values) = kv_namespaces {
+        let old_format = values.iter().any(|val| val.clone().into_str().is_ok());
+
+        if old_format {
+            message::warn("As of 1.1.0 the kv-namespaces format has been stabilized");
+            message::info("Please add a section like this in your `wrangler.toml` for each KV Namespace you wish to bind:");
+
+            let fmt_demo = r##"
+[[kv-namespaces]]
+binding = "BINDING_NAME"
+id = "0f2ac74b498b48028cb68387c421e279"
+
+# binding is the variable name you wish to bind the namespace to in your script.
+# id is the namespace_id assigned to your kv namespace upon creation. e.g. (per namespace)
+"##;
+
+            println!("{}", fmt_demo);
+
+            let msg = format!("{0} Your project config has an error {0}", emoji::WARN);
+            failure::bail!(msg)
+        }
+    }
+
     let project: Result<Project, config::ConfigError> = s.try_into();
     match project {
         Ok(s) => Ok(s),
@@ -126,3 +124,6 @@ pub fn get_project_config() -> Result<Project, failure::Error> {
         }
     }
 }
+
+#[cfg(test)]
+mod tests;
diff --git a/src/settings/project/project_type.rs b/src/settings/project/project_type.rs
new file mode 100644
index 000000000..b5b010414
--- /dev/null
+++ b/src/settings/project/project_type.rs
@@ -0,0 +1,42 @@
+use std::fmt;
+use std::str::FromStr;
+
+use serde::{Deserialize, Serialize};
+
+#[derive(Clone, Debug, Deserialize, Serialize)]
+#[serde(rename_all = "lowercase")]
+pub enum ProjectType {
+    JavaScript,
+    Rust,
+    Webpack,
+}
+
+impl Default for ProjectType {
+    fn default() -> Self {
+        ProjectType::Webpack
+    }
+}
+
+impl fmt::Display for ProjectType {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let printable = match *self {
+            ProjectType::JavaScript => "js",
+            ProjectType::Rust => "rust",
+            ProjectType::Webpack => "webpack",
+        };
+        write!(f, "{}", printable)
+    }
+}
+
+impl FromStr for ProjectType {
+    type Err = failure::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "javascript" => Ok(ProjectType::JavaScript),
+            "rust" => Ok(ProjectType::Rust),
+            "webpack" => Ok(ProjectType::Webpack),
+            _ => failure::bail!("{} is not a valid wrangler project type!", s),
+        }
+    }
+}
diff --git a/src/settings/project/tests/mod.rs b/src/settings/project/tests/mod.rs
new file mode 100644
index 000000000..ffb6ad6dc
--- /dev/null
+++ b/src/settings/project/tests/mod.rs
@@ -0,0 +1,51 @@
+use super::*;
+
+use std::env;
+use std::path::{Path, PathBuf};
+
+#[test]
+fn it_builds_from_config() {
+    let toml_path = toml_fixture_path("default");
+
+    let project = get_project_config(&toml_path).unwrap();
+
+    assert!(project.kv_namespaces.is_none());
+}
+
+#[test]
+fn it_builds_from_config_with_kv() {
+    let toml_path = toml_fixture_path("kv_namespaces");
+
+    let project = get_project_config(&toml_path).unwrap();
+
+    let kv_1 = KvNamespace {
+        id: "somecrazylongidentifierstring".to_string(),
+        binding: "prodKV".to_string(),
+    };
+    let kv_2 = KvNamespace {
+        id: "anotherwaytoolongidstring".to_string(),
+        binding: "stagingKV".to_string(),
+    };
+
+    match project.kv_namespaces {
+        Some(kv_namespaces) => {
+            assert!(kv_namespaces.len() == 2);
+            assert!(kv_namespaces.contains(&kv_1));
+            assert!(kv_namespaces.contains(&kv_2));
+        }
+        None => assert!(false),
+    }
+}
+
+fn toml_fixture_path(fixture: &str) -> PathBuf {
+    let current_dir = env::current_dir().unwrap();
+
+    // TODO: This is kind of stupid but idk worth it for now?
+    Path::new(&current_dir)
+        .join("src")
+        .join("settings")
+        .join("project")
+        .join("tests")
+        .join("tomls")
+        .join(fixture)
+}
diff --git a/src/settings/project/tests/tomls/default.toml b/src/settings/project/tests/tomls/default.toml
new file mode 100644
index 000000000..cbb639931
--- /dev/null
+++ b/src/settings/project/tests/tomls/default.toml
@@ -0,0 +1,6 @@
+name = "worker"
+type = "webpack"
+zone_id = ""
+private = false
+account_id = ""
+route = ""
diff --git a/src/settings/project/tests/tomls/kv_namespaces.toml b/src/settings/project/tests/tomls/kv_namespaces.toml
new file mode 100644
index 000000000..66dcc380b
--- /dev/null
+++ b/src/settings/project/tests/tomls/kv_namespaces.toml
@@ -0,0 +1,14 @@
+name = "worker"
+type = "webpack"
+zone_id = ""
+private = false
+account_id = ""
+route = ""
+
+[[kv-namespaces]]
+id = "somecrazylongidentifierstring"
+binding = "prodKV"
+
+[[kv-namespaces]]
+id = "anotherwaytoolongidstring"
+binding = "stagingKV"
diff --git a/src/terminal/emoji.rs b/src/terminal/emoji.rs
index bec4e7248..da62fa835 100644
--- a/src/terminal/emoji.rs
+++ b/src/terminal/emoji.rs
@@ -13,7 +13,6 @@
 
 use console::Emoji;
 
-pub static CONSTRUCTION: Emoji = Emoji("🚧 ", "");
 pub static CRAB: Emoji = Emoji("🦀 ", "");
 pub static DANCERS: Emoji = Emoji("👯 ", "");
 pub static EYES: Emoji = Emoji("👀 ", "");
diff --git a/src/terminal/message.rs b/src/terminal/message.rs
index c32d78532..1a105a3f4 100644
--- a/src/terminal/message.rs
+++ b/src/terminal/message.rs
@@ -9,6 +9,10 @@ pub fn info(msg: &str) {
     message(emoji::INFO, msg);
 }
 
+pub fn warn(msg: &str) {
+    message(emoji::WARN, msg);
+}
+
 pub fn success(msg: &str) {
     message(emoji::SPARKLES, msg);
 }
diff --git a/tests/build.rs b/tests/build.rs
index e4133ff47..ef6a535a7 100644
--- a/tests/build.rs
+++ b/tests/build.rs
@@ -38,7 +38,6 @@ fn it_builds_with_webpack_single_js() {
 
     build(fixture);
     assert!(fixture_out_path(fixture).join("script.js").exists());
-    assert!(fixture_out_path(fixture).join("metadata.json").exists());
     cleanup(fixture);
 }
 
@@ -53,7 +52,6 @@ fn it_builds_with_webpack_single_js_use_package_main() {
 
     build(fixture);
     assert!(fixture_out_path(fixture).join("script.js").exists());
-    assert!(fixture_out_path(fixture).join("metadata.json").exists());
     cleanup(fixture);
 }
 
@@ -126,13 +124,8 @@ fn it_builds_with_webpack_wast() {
 
     build(fixture);
     assert!(fixture_out_path(fixture).join("script.js").exists());
-    assert!(fixture_out_path(fixture).join("metadata.json").exists());
     assert!(fixture_out_path(fixture).join("module.wasm").exists());
 
-    let metadata = fs::read_to_string(fixture_out_path(fixture).join("metadata.json"))
-        .expect("could not read metadata");
-    assert!(metadata.contains("wasm_module"));
-
     cleanup(fixture);
 }
 
diff --git a/tests/config.rs b/tests/config.rs
new file mode 100644
index 000000000..74640b2d3
--- /dev/null
+++ b/tests/config.rs
@@ -0,0 +1,59 @@
+use assert_cmd::prelude::*;
+use std::env;
+use std::fs;
+use std::io::prelude::*;
+use std::process::{Child, Command, Stdio};
+
+#[test]
+fn it_generates_the_config() {
+    let fake_home_dir = env::current_dir()
+        .expect("could not retrieve cwd")
+        .join(".it_generates_the_config");
+    let cmd = config_with_wrangler_home(fake_home_dir.to_str().unwrap());
+    let mut stdin = cmd.stdin.unwrap();
+
+    write!(stdin, "email@example.com\n").unwrap();
+    write!(stdin, "apikeythisissecretandlong\n").unwrap();
+
+    let mut buffer = "".to_string();
+    let mut stdout = cmd.stdout.expect("stdout");
+    stdout
+        .read_to_string(&mut buffer)
+        .expect("could not read output");
+    assert!(buffer.contains("Successfully configured."));
+
+    let config_file = fake_home_dir.join("config").join("default.toml");
+
+    let config = fs::read_to_string(&config_file)
+        .expect(&format!("could not read config at {:?}", &config_file));
+    assert_eq!(
+        config,
+        r#"email = "email@example.com"
+api_key = "apikeythisissecretandlong"
+"#
+    );
+
+    // check dir permissions (linux only)
+    if cfg!(target_os = "linux") {
+        let mut command = Command::new("stat");
+        command.arg("-c");
+        command.arg("%a %n");
+        command.arg(&config_file);
+        let out = String::from_utf8(command.output().expect("could not stat file").stdout).unwrap();
+        // stat format is: "mode file"
+        assert!(out.starts_with("600"));
+    }
+
+    fs::remove_dir_all(&fake_home_dir).expect("could not delete dir");
+}
+
+fn config_with_wrangler_home(home_dir: &str) -> Child {
+    let mut wrangler = Command::cargo_bin(env!("CARGO_PKG_NAME")).unwrap();
+    wrangler
+        .arg("config")
+        .stdin(Stdio::piped())
+        .stdout(Stdio::piped())
+        .env("WRANGLER_HOME", home_dir)
+        .spawn()
+        .unwrap()
+}
diff --git a/tests/preview.rs b/tests/preview.rs
new file mode 100644
index 000000000..a6215cfea
--- /dev/null
+++ b/tests/preview.rs
@@ -0,0 +1,102 @@
+use assert_cmd::prelude::*;
+use fs_extra::dir::{copy, CopyOptions};
+use std::env;
+use std::fs;
+use std::fs::File;
+use std::io::prelude::*;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+use std::str;
+
+macro_rules! settings {
+    ( $f:expr, $x:expr ) => {
+        let file_path = fixture_path($f).join("wrangler.toml");
+        let mut file = File::create(file_path).unwrap();
+        let content = format!(
+            r#"
+            name = "test"
+            zone_id = ""
+            account_id = ""
+            {}
+        "#,
+            $x
+        );
+        file.write_all(content.as_bytes()).unwrap();
+    };
+}
+
+#[test]
+fn it_can_preview_js_project() {
+    let fixture = "simple_js";
+    create_temporary_copy(fixture);
+    settings! {fixture, r#"
+        type = "javascript"
+    "#};
+    preview(fixture);
+    cleanup(fixture);
+}
+
+#[test]
+fn it_can_preview_webpack_project() {
+    let fixture = "webpack_simple_js";
+    create_temporary_copy(fixture);
+    settings! {fixture, r#"
+        type = "webpack"
+    "#};
+    preview(fixture);
+    cleanup(fixture);
+}
+
+#[test]
+fn it_can_preview_rust_project() {
+    let fixture = "simple_rust";
+    create_temporary_copy(fixture);
+    settings! {fixture, r#"
+        type = "rust"
+    "#};
+    preview(fixture);
+    cleanup(fixture);
+}
+
+fn preview(fixture: &str) {
+    let mut preview = Command::cargo_bin(env!("CARGO_PKG_NAME")).unwrap();
+    preview.current_dir(fixture_path(fixture));
+    preview.arg("preview").assert().success();
+}
+
+fn cleanup(fixture: &str) {
+    let path = fixture_path(fixture);
+    assert!(path.exists(), format!("{:?} does not exist", path));
+
+    // Workaround https://github.com/rust-lang/rust/issues/29497
+    if cfg!(target_os = "windows") {
+        let mut command = Command::new("cmd");
+        command.arg("rmdir");
+        command.arg("/s");
+        command.arg(&path);
+    } else {
+        fs::remove_dir_all(&path).unwrap();
+    }
+}
+
+fn fixture_path(fixture: &str) -> PathBuf {
+    let mut dest = env::temp_dir();
+    dest.push(fixture);
+    dest
+}
+
+fn create_temporary_copy(fixture: &str) {
+    let current_dir = env::current_dir().unwrap();
+    let src = Path::new(&current_dir).join("tests").join(fixture);
+
+    let dest = env::temp_dir();
+
+    if dest.join(fixture).exists() {
+        cleanup(fixture);
+    }
+
+    fs::create_dir_all(dest.clone()).unwrap();
+    let mut options = CopyOptions::new();
+    options.overwrite = true;
+    copy(src, dest, &options).unwrap();
+}
diff --git a/tests/simple_js/index.js b/tests/simple_js/index.js
new file mode 100644
index 000000000..6df309c69
--- /dev/null
+++ b/tests/simple_js/index.js
@@ -0,0 +1,11 @@
+addEventListener('fetch', event => {
+    event.respondWith(handleRequest(event.request))
+  })
+  
+  /**
+   * Fetch and log a request
+   * @param {Request} request
+   */
+  async function handleRequest(request) {
+    return new Response('Hello worker!', { status: 200 })
+  }
\ No newline at end of file
diff --git a/tests/simple_js/package.json b/tests/simple_js/package.json
new file mode 100644
index 000000000..1f4546b29
--- /dev/null
+++ b/tests/simple_js/package.json
@@ -0,0 +1,3 @@
+{
+    "main": "index.js"
+}
\ No newline at end of file
diff --git a/tests/simple_rust/Cargo.toml b/tests/simple_rust/Cargo.toml
new file mode 100644
index 000000000..a8b8daf41
--- /dev/null
+++ b/tests/simple_rust/Cargo.toml
@@ -0,0 +1,35 @@
+[package]
+name = "worker"
+version = "0.1.0"
+authors = ["Avery Harnish <averyharnish@gmail.com>"]
+edition = "2018"
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+[features]
+default = ["console_error_panic_hook"]
+
+[dependencies]
+cfg-if = "0.1.2"
+wasm-bindgen = "0.2"
+
+# The `console_error_panic_hook` crate provides better debugging of panics by
+# logging them with `console.error`. This is great for development, but requires
+# all the `std::fmt` and `std::panicking` infrastructure, so isn't great for
+# code size when deploying.
+console_error_panic_hook = { version = "0.1.1", optional = true }
+
+# `wee_alloc` is a tiny allocator for wasm that is only ~1K in code size
+# compared to the default allocator's ~10K. It is slower than the default
+# allocator, however.
+#
+# Unfortunately, `wee_alloc` requires nightly Rust when targeting wasm for now.
+wee_alloc = { version = "0.4.2", optional = true }
+
+[dev-dependencies]
+wasm-bindgen-test = "0.2"
+
+[profile.release]
+# Tell `rustc` to optimize for small code size.
+opt-level = "s"
diff --git a/tests/simple_rust/src/lib.rs b/tests/simple_rust/src/lib.rs
new file mode 100644
index 000000000..b17d4f947
--- /dev/null
+++ b/tests/simple_rust/src/lib.rs
@@ -0,0 +1,22 @@
+extern crate cfg_if;
+extern crate wasm_bindgen;
+
+mod utils;
+
+use cfg_if::cfg_if;
+use wasm_bindgen::prelude::*;
+
+cfg_if! {
+    // When the `wee_alloc` feature is enabled, use `wee_alloc` as the global
+    // allocator.
+    if #[cfg(feature = "wee_alloc")] {
+        extern crate wee_alloc;
+        #[global_allocator]
+        static ALLOC: wee_alloc::WeeAlloc = wee_alloc::WeeAlloc::INIT;
+    }
+}
+
+#[wasm_bindgen]
+pub fn greet() -> String {
+    "Hello, wasm-worker!".to_string()
+}
diff --git a/tests/simple_rust/src/utils.rs b/tests/simple_rust/src/utils.rs
new file mode 100644
index 000000000..2ffc954db
--- /dev/null
+++ b/tests/simple_rust/src/utils.rs
@@ -0,0 +1,17 @@
+use cfg_if::cfg_if;
+
+cfg_if! {
+    // When the `console_error_panic_hook` feature is enabled, we can call the
+    // `set_panic_hook` function at least once during initialization, and then
+    // we will get better error messages if our code ever panics.
+    //
+    // For more details see
+    // https://github.com/rustwasm/console_error_panic_hook#readme
+    if #[cfg(feature = "console_error_panic_hook")] {
+        extern crate console_error_panic_hook;
+        pub use self::console_error_panic_hook::set_once as set_panic_hook;
+    } else {
+        #[inline]
+        pub fn set_panic_hook() {}
+    }
+}
diff --git a/tests/simple_rust/worker/metadata_wasm.json b/tests/simple_rust/worker/metadata_wasm.json
new file mode 100644
index 000000000..afc6d35fb
--- /dev/null
+++ b/tests/simple_rust/worker/metadata_wasm.json
@@ -0,0 +1,10 @@
+{
+    "body_part": "script",
+    "bindings": [
+        {
+            "name": "wasm",
+            "type": "wasm_module",
+            "part": "wasmprogram"
+        }
+    ]
+}
diff --git a/tests/simple_rust/worker/worker.js b/tests/simple_rust/worker/worker.js
new file mode 100644
index 000000000..10ec9a282
--- /dev/null
+++ b/tests/simple_rust/worker/worker.js
@@ -0,0 +1,14 @@
+addEventListener('fetch', event => {
+  event.respondWith(handleRequest(event.request))
+})
+
+/**
+ * Fetch and log a request
+ * @param {Request} request
+ */
+async function handleRequest(request) {
+    const { greet } = wasm_bindgen;
+    await wasm_bindgen(wasm)
+    const greeting = greet()
+    return new Response(greeting, {status: 200})
+}
diff --git a/tests/webpack_simple_js/index.js b/tests/webpack_simple_js/index.js
index 5baefb160..6df309c69 100644
--- a/tests/webpack_simple_js/index.js
+++ b/tests/webpack_simple_js/index.js
@@ -1 +1,11 @@
-// js
+addEventListener('fetch', event => {
+    event.respondWith(handleRequest(event.request))
+  })
+  
+  /**
+   * Fetch and log a request
+   * @param {Request} request
+   */
+  async function handleRequest(request) {
+    return new Response('Hello worker!', { status: 200 })
+  }
\ No newline at end of file