Merge lp:~urbanape/bindwood/using-oauth into lp:bindwood

[Zachery Bir]

This branch enables OAuth integration for Bindwood.

[Zachery Bir (urbanape)]

This branch enables OAuth integration with our Desktop CouchDB.

[Tim Cole (tcole)]

Looks okay. Good catch with the semicolons.

review: Approve

[lp:~urbanape/bindwood/using-oauth]

21. By Zachery Bir on 2009-09-08

Woops, renamed this variable

[Guillermo Gonzalez (verterok)]

review: Approve

=== modified file 'content/browserOverlay.xul'
--- content/browserOverlay.xul	2009-08-18 14:17:30 +0000
+++ content/browserOverlay.xul	2009-09-02 17:07:11 +0000
@@ -19,6 +19,8 @@
 <overlay id="bindwood"
          xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul">
 
+  <script type="application/x-javascript" src="chrome://bindwood/content/sha1.js" />
+  <script type="application/x-javascript" src="chrome://bindwood/content/oauth.js" />
   <script type="application/x-javascript" src="chrome://bindwood/content/couch.js" />
   <script type="application/x-javascript" src="chrome://bindwood/content/sync.js" />
 
 
=== modified file 'content/couch.js'
--- content/couch.js	2009-07-08 01:24:33 +0000
+++ content/couch.js	2009-09-08 15:29:55 +0000
@@ -1,12 +1,12 @@
 // Licensed under the Apache License, Version 2.0 (the "License"); you may not
-// use this file except in compliance with the License.  You may obtain a copy
-// of the License at
+// use this file except in compliance with the License. You may obtain a copy of
+// the License at
 //
 //   http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
+// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 // License for the specific language governing permissions and limitations under
 // the License.
 
@@ -22,17 +22,26 @@
   this.last_req = null;
 
   this.request = function(method, uri, requestOptions) {
-      requestOptions = requestOptions || {}
-      requestOptions.headers = combine(requestOptions.headers, httpHeaders)
+      CouchDB.message.action = uri;
+      Bindwood.writeMessage("Set the action of the CouchDB.message to: " + uri);
+      CouchDB.message.method = method;
+      Bindwood.writeMessage("Set the method of the CouchDB.message to: " + method);
+      OAuth.completeRequest(CouchDB.message, CouchDB.accessor);
+      Bindwood.writeMessage("Signed the message");
+      var parameters = CouchDB.message.parameters;
+      requestOptions = requestOptions || {};
+      requestOptions.headers = combine(requestOptions.headers, httpHeaders);
+      requestOptions.headers = combine(requestOptions.headers, {Authorization: OAuth.getAuthorizationHeader('', parameters)});
+      Bindwood.writeMessage("Request headers: " + JSON.stringify(headers));
       return CouchDB.request(method, uri, requestOptions);
-    }
+  };
 
   // Creates the database on the server
   this.createDb = function() {
     this.last_req = this.request("PUT", this.uri);
     CouchDB.maybeThrowError(this.last_req);
     return JSON.parse(this.last_req.responseText);
-  }
+  };
 
   // Deletes the database on the server
   this.deleteDb = function() {
@@ -41,7 +50,7 @@
       return false;
     CouchDB.maybeThrowError(this.last_req);
     return JSON.parse(this.last_req.responseText);
-  }
+  };
 
   // Save a document to the database
   this.save = function(doc, options) {
@@ -55,7 +64,7 @@
     var result = JSON.parse(this.last_req.responseText);
     doc._rev = result.rev;
     return result;
-  }
+  };
 
   // Open a document from the database
   this.open = function(docId, options) {
@@ -64,7 +73,7 @@
       return null;
     CouchDB.maybeThrowError(this.last_req);
     return JSON.parse(this.last_req.responseText);
-  }
+  };
 
   // Deletes a document from the database
   this.deleteDoc = function(doc) {
@@ -74,7 +83,7 @@
     doc._rev = result.rev; //record rev in input document
     doc._deleted = true;
     return result;
-  }
+  };
 
   // Deletes an attachment from a document
   this.deleteDocAttachment = function(doc, attachment_name) {
@@ -83,17 +92,17 @@
     var result = JSON.parse(this.last_req.responseText);
     doc._rev = result.rev; //record rev in input document
     return result;
-  }
+  };
 
   this.bulkSave = function(docs, options) {
     // first prepoulate the UUIDs for new documents
-    var newCount = 0
+    var newCount = 0;
     for (var i=0; i<docs.length; i++) {
       if (docs[i]._id == undefined)
         newCount++;
     }
     var newUuids = CouchDB.newUuids(docs.length);
-    var newCount = 0
+    var newCount = 0;
     for (var i=0; i<docs.length; i++) {
       if (docs[i]._id == undefined)
         docs[i]._id = newUuids.pop();
@@ -118,17 +127,17 @@
       }
       return results;
     }
-  }
+  };
 
   this.ensureFullCommit = function() {
     this.last_req = this.request("POST", this.uri + "_ensure_full_commit");
     CouchDB.maybeThrowError(this.last_req);
     return JSON.parse(this.last_req.responseText);
-  }
+  };
 
   // Applies the map function to the contents of database and returns the results.
-  this.query = function(mapFun, reduceFun, options, keys) {
-    var body = {language: "javascript"};
+  this.query = function(mapFun, reduceFun, options, keys, language) {
+    var body = {language: language || "javascript"};
     if(keys) {
       body.keys = keys ;
     }
@@ -144,13 +153,16 @@
         body.options = options.options;
         delete options.options;
     }
-    this.last_req = this.request("POST", this.uri + "_temp_view" + encodeOptions(options), {
+    var uri = this.uri + "_temp_view" + encodeOptions(options);
+    Bindwood.writeMessage("Query URI: " + uri);
+    Bindwood.writeMessage("Query body: " + JSON.stringify(body));
+    this.last_req = this.request("POST", uri , {
       headers: {"Content-Type": "application/json"},
       body: JSON.stringify(body)
     });
     CouchDB.maybeThrowError(this.last_req);
     return JSON.parse(this.last_req.responseText);
-  }
+  };
 
   this.view = function(viewname, options, keys) {
     var viewParts = viewname.split('/');
@@ -168,14 +180,27 @@
       return null;
     CouchDB.maybeThrowError(this.last_req);
     return JSON.parse(this.last_req.responseText);
-  }
+  };
 
   // gets information about the database
   this.info = function() {
     this.last_req = this.request("GET", this.uri);
     CouchDB.maybeThrowError(this.last_req);
     return JSON.parse(this.last_req.responseText);
-  }
+  };
+
+  // gets information about a design doc
+  this.designInfo = function(docid) {
+    this.last_req = this.request("GET", this.uri + docid + "/_info");
+    CouchDB.maybeThrowError(this.last_req);
+    return JSON.parse(this.last_req.responseText);
+  };
+
+  this.viewCleanup = function() {
+    this.last_req = this.request("POST", this.uri + "_view_cleanup");
+    CouchDB.maybeThrowError(this.last_req);
+    return JSON.parse(this.last_req.responseText);
+  };
 
   this.allDocs = function(options,keys) {
     if(!keys) {
@@ -188,7 +213,7 @@
     }
     CouchDB.maybeThrowError(this.last_req);
     return JSON.parse(this.last_req.responseText);
-  }
+  };
 
   this.designDocs = function() {
     return this.allDocs({startkey:"_design", endkey:"_design0"});
@@ -206,13 +231,13 @@
     }
     CouchDB.maybeThrowError(req);
     return JSON.parse(req.responseText);
-  }
+  };
 
   this.compact = function() {
     this.last_req = this.request("POST", this.uri + "_compact");
     CouchDB.maybeThrowError(this.last_req);
     return JSON.parse(this.last_req.responseText);
-  }
+  };
 
   this.setDbProperty = function(propId, propValue) {
     this.last_req = this.request("PUT", this.uri + propId,{
@@ -220,13 +245,13 @@
     });
     CouchDB.maybeThrowError(this.last_req);
     return JSON.parse(this.last_req.responseText);
-  }
+  };
 
   this.getDbProperty = function(propId) {
     this.last_req = this.request("GET", this.uri + propId);
     CouchDB.maybeThrowError(this.last_req);
     return JSON.parse(this.last_req.responseText);
-  }
+  };
 
   this.setAdmins = function(adminsArray) {
     this.last_req = this.request("PUT", this.uri + "_admins",{
@@ -234,18 +259,18 @@
     });
     CouchDB.maybeThrowError(this.last_req);
     return JSON.parse(this.last_req.responseText);
-  }
+  };
 
   this.getAdmins = function() {
     this.last_req = this.request("GET", this.uri + "_admins");
     CouchDB.maybeThrowError(this.last_req);
     return JSON.parse(this.last_req.responseText);
-  }
+  };
 
   // Convert a options object to an url query string.
   // ex: {key:'value',key2:'value2'} becomes '?key="value"&key2="value2"'
   function encodeOptions(options) {
-    var buf = []
+    var buf = [];
     if (typeof(options) == "object" && options !== null) {
       for (var name in options) {
         if (!options.hasOwnProperty(name)) continue;
@@ -278,22 +303,82 @@
     return object1;
   }
 
-
 }
 
-CouchDB.PORT_NUMBER = 5984; // default
-
 // this is the XMLHttpRequest object from last request made by the following
 // CouchDB.* functions (except for calls to request itself).
 // Use this from callers to check HTTP status or header values of requests.
 CouchDB.last_req = null;
 
+CouchDB.login = function(username, password) {
+  CouchDB.last_req = CouchDB.request("POST", "/_session", {
+    headers: {"Content-Type": "application/x-www-form-urlencoded",
+      "X-CouchDB-WWW-Authenticate": "Cookie"},
+    body: "username=" + encodeURIComponent(username) + "&password=" + encodeURIComponent(password)
+  });
+  return JSON.parse(CouchDB.last_req.responseText);
+};
+
+CouchDB.logout = function() {
+  CouchDB.last_req = CouchDB.request("DELETE", "/_session", {
+    headers: {"Content-Type": "application/x-www-form-urlencoded",
+      "X-CouchDB-WWW-Authenticate": "Cookie"}
+  });
+  return JSON.parse(CouchDB.last_req.responseText);
+};
+
+CouchDB.createUser = function(username, password, email, roles, basicAuth) {
+  var roles_str = "";
+  if (roles) {
+    for (var i=0; i< roles.length; i++) {
+      roles_str += "&roles=" + encodeURIComponent(roles[i]);
+    }
+  }
+  var headers = {"Content-Type": "application/x-www-form-urlencoded"};
+  if (basicAuth) {
+    headers['Authorization'] = basicAuth;
+  } else {
+    headers['X-CouchDB-WWW-Authenticate'] = 'Cookie';
+  }
+
+  CouchDB.last_req = CouchDB.request("POST", "/_user/", {
+    headers: headers,
+    body: "username=" + encodeURIComponent(username) + "&password=" + encodeURIComponent(password)
+          + "&email="+ encodeURIComponent(email)+ roles_str
+
+  });
+  return JSON.parse(CouchDB.last_req.responseText);
+};
+
+CouchDB.updateUser = function(username, email, roles, password, old_password) {
+  var roles_str = "";
+  if (roles) {
+    for (var i=0; i< roles.length; i++) {
+      roles_str += "&roles=" + encodeURIComponent(roles[i]);
+    }
+  }
+
+  var body = "email="+ encodeURIComponent(email)+ roles_str;
+
+  if (typeof(password) != "undefined" && password)
+    body += "&password=" + password;
+
+  if (typeof(old_password) != "undefined" && old_password)
+    body += "&old_password=" + old_password;
+
+  CouchDB.last_req = CouchDB.request("PUT", "/_user/"+encodeURIComponent(username), {
+    headers: {"Content-Type": "application/x-www-form-urlencoded",
+      "X-CouchDB-WWW-Authenticate": "Cookie"},
+    body: body
+  });
+  return JSON.parse(CouchDB.last_req.responseText);
+};
 
 CouchDB.allDbs = function() {
   CouchDB.last_req = CouchDB.request("GET", "/_all_dbs");
     CouchDB.maybeThrowError(CouchDB.last_req);
   return JSON.parse(CouchDB.last_req.responseText);
-}
+};
 
 CouchDB.allDesignDocs = function() {
   var ddocs = {}, dbs = CouchDB.allDbs();
@@ -308,7 +393,7 @@
   CouchDB.last_req = CouchDB.request("GET", "/");
   CouchDB.maybeThrowError(CouchDB.last_req);
   return JSON.parse(CouchDB.last_req.responseText).version;
-}
+};
 
 CouchDB.replicate = function(source, target, rep_options) {
   rep_options = rep_options || {};
@@ -319,29 +404,40 @@
   });
   CouchDB.maybeThrowError(CouchDB.last_req);
   return JSON.parse(CouchDB.last_req.responseText);
-}
+};
 
-CouchDB.request = function(method, uri, options) {
-  options = options || {};
-  var req = null;
+CouchDB.newXhr = function() {
   if (typeof(XMLHttpRequest) != "undefined") {
-    req = new XMLHttpRequest();
+    return new XMLHttpRequest();
   } else if (typeof(ActiveXObject) != "undefined") {
-    req = new ActiveXObject("Microsoft.XMLHTTP");
+    return new ActiveXObject("Microsoft.XMLHTTP");
   } else {
     throw new Error("No XMLHTTPRequest support detected");
   }
-  req.open(method, "http://localhost:" + CouchDB.PORT_NUMBER + uri, false);
+};
+
+CouchDB.request = function(method, uri, options) {
+  options = options || {};
+  var req = CouchDB.newXhr();
+  var computed_uri = "http://localhost:" + CouchDB.port + uri;
+  Bindwood.writeMessage("Opening a request to: " + computed_uri);
+  req.open(method, computed_uri, false);
   if (options.headers) {
+    Bindwood.writeMessage("Setting optional headers");
     var headers = options.headers;
     for (var headerName in headers) {
       if (!headers.hasOwnProperty(headerName)) continue;
       req.setRequestHeader(headerName, headers[headerName]);
     }
   }
-  req.send(options.body || "");
+  Bindwood.writeMessage("Sending the request");
+  try {
+    req.send(options.body || "");
+  } catch(e) {
+    Bindwood.writeError("Problem sending request: ", e);
+  }
   return req;
-}
+};
 
 CouchDB.requestStats = function(module, key, test) {
   var query_arg = "";
@@ -351,7 +447,7 @@
 
   var stat = CouchDB.request("GET", "/_stats/" + module + "/" + key + query_arg).responseText;
   return JSON.parse(stat)[module][key];
-}
+};
 
 CouchDB.uuids_cache = [];
 
@@ -373,7 +469,7 @@
         CouchDB.uuids_cache.concat(result.uuids.slice(0, 100));
     return result.uuids.slice(100);
   }
-}
+};
 
 CouchDB.maybeThrowError = function(req) {
   if (req.status >= 400) {
@@ -384,7 +480,7 @@
     }
     throw result;
   }
-}
+};
 
 CouchDB.params = function(options) {
   options = options || {};
@@ -394,4 +490,4 @@
     returnArray.push(key + "=" + value);
   }
   return returnArray.join("&");
-}
+};
 
=== added file 'content/oauth.js'
--- content/oauth.js	1970-01-01 00:00:00 +0000
+++ content/oauth.js	2009-09-04 14:10:27 +0000
@@ -0,0 +1,515 @@
+/*
+ * Copyright 2008 Netflix, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/* Here's some JavaScript software for implementing OAuth.
+
+   This isn't as useful as you might hope.  OAuth is based around
+   allowing tools and websites to talk to each other.  However,
+   JavaScript running in web browsers is hampered by security
+   restrictions that prevent code running on one website from
+   accessing data stored or served on another.
+
+   Before you start hacking, make sure you understand the limitations
+   posed by cross-domain XMLHttpRequest.
+
+   On the bright side, some platforms use JavaScript as their
+   language, but enable the programmer to access other web sites.
+   Examples include Google Gadgets, and Microsoft Vista Sidebar.
+   For those platforms, this library should come in handy.
+*/
+
+// The HMAC-SHA1 signature method calls b64_hmac_sha1, defined by
+// http://pajhome.org.uk/crypt/md5/sha1.js
+
+/* An OAuth message is represented as an object like this:
+   {method: "GET", action: "http://server.com/path", parameters: ...}
+
+   The parameters may be either a map {name: value, name2: value2}
+   or an Array of name-value pairs [[name, value], [name2, value2]].
+   The latter representation is more powerful: it supports parameters
+   in a specific sequence, or several parameters with the same name;
+   for example [["a", 1], ["b", 2], ["a", 3]].
+
+   Parameter names and values are NOT percent-encoded in an object.
+   They must be encoded before transmission and decoded after reception.
+   For example, this message object:
+   {method: "GET", action: "http://server/path", parameters: {p: "x y"}}
+   ... can be transmitted as an HTTP request that begins:
+   GET /path?p=x%20y HTTP/1.0
+   (This isn't a valid OAuth request, since it lacks a signature etc.)
+   Note that the object "x y" is transmitted as x%20y.  To encode
+   parameters, you can call OAuth.addToURL, OAuth.formEncode or
+   OAuth.getAuthorization.
+
+   This message object model harmonizes with the browser object model for
+   input elements of an form, whose value property isn't percent encoded.
+   The browser encodes each value before transmitting it. For example,
+   see consumer.setInputs in example/consumer.js.
+ */
+var OAuth; if (OAuth == null) OAuth = {};
+
+OAuth.setProperties = function setProperties(into, from) {
+    if (into != null && from != null) {
+        for (var key in from) {
+            into[key] = from[key];
+        }
+    }
+    return into;
+}
+
+OAuth.setProperties(OAuth, // utility functions
+{
+    percentEncode: function percentEncode(s) {
+        if (s == null) {
+            return "";
+        }
+        if (s instanceof Array) {
+            var e = "";
+            for (var i = 0; i < s.length; ++s) {
+                if (e != "") e += '&';
+                e += percentEncode(s[i]);
+            }
+            return e;
+        }
+        s = encodeURIComponent(s);
+        // Now replace the values which encodeURIComponent doesn't do
+        // encodeURIComponent ignores: - _ . ! ~ * ' ( )
+        // OAuth dictates the only ones you can ignore are: - _ . ~
+        // Source: http://developer.mozilla.org/en/docs/Core_JavaScript_1.5_Reference:Global_Functions:encodeURIComponent
+        s = s.replace(/\!/g, "%21");
+        s = s.replace(/\*/g, "%2A");
+        s = s.replace(/\'/g, "%27");
+        s = s.replace(/\(/g, "%28");
+        s = s.replace(/\)/g, "%29");
+        return s;
+    }
+,
+    decodePercent: function decodePercent(s) {
+        if (s != null) {
+            // Handle application/x-www-form-urlencoded, which is defined by
+            // http://www.w3.org/TR/html4/interact/forms.html#h-17.13.4.1
+            s = s.replace(/\+/g, " ");
+        }
+        return decodeURIComponent(s);
+    }
+,
+    /** Convert the given parameters to an Array of name-value pairs. */
+    getParameterList: function getParameterList(parameters) {
+        if (parameters == null) {
+            return [];
+        }
+        if (typeof parameters != "object") {
+            return decodeForm(parameters + "");
+        }
+        if (parameters instanceof Array) {
+            return parameters;
+        }
+        var list = [];
+        for (var p in parameters) {
+            list.push([p, parameters[p]]);
+        }
+        return list;
+    }
+,
+    /** Convert the given parameters to a map from name to value. */
+    getParameterMap: function getParameterMap(parameters) {
+        if (parameters == null) {
+            return {};
+        }
+        if (typeof parameters != "object") {
+            return getParameterMap(decodeForm(parameters + ""));
+        }
+        if (parameters instanceof Array) {
+            var map = {};
+            for (var p = 0; p < parameters.length; ++p) {
+                var key = parameters[p][0];
+                if (map[key] === undefined) { // first value wins
+                    map[key] = parameters[p][1];
+                }
+            }
+            return map;
+        }
+        return parameters;
+    }
+,
+    getParameter: function getParameter(parameters, name) {
+        if (parameters instanceof Array) {
+            for (var p = 0; p < parameters.length; ++p) {
+                if (parameters[p][0] == name) {
+                    return parameters[p][1]; // first value wins
+                }
+            }
+        } else {
+            return OAuth.getParameterMap(parameters)[name];
+        }
+        return null;
+    }
+,
+    formEncode: function formEncode(parameters) {
+        var form = "";
+        var list = OAuth.getParameterList(parameters);
+        for (var p = 0; p < list.length; ++p) {
+            var value = list[p][1];
+            if (value == null) value = "";
+            if (form != "") form += '&';
+            form += OAuth.percentEncode(list[p][0])
+              +'='+ OAuth.percentEncode(value);
+        }
+        return form;
+    }
+,
+    decodeForm: function decodeForm(form) {
+        var list = [];
+        var nvps = form.split('&');
+        for (var n = 0; n < nvps.length; ++n) {
+            var nvp = nvps[n];
+            if (nvp == "") {
+                continue;
+            }
+            var equals = nvp.indexOf('=');
+            var name;
+            var value;
+            if (equals < 0) {
+                name = OAuth.decodePercent(nvp);
+                value = null;
+            } else {
+                name = OAuth.decodePercent(nvp.substring(0, equals));
+                value = OAuth.decodePercent(nvp.substring(equals + 1));
+            }
+            list.push([name, value]);
+        }
+        return list;
+    }
+,
+    setParameter: function setParameter(message, name, value) {
+        var parameters = message.parameters;
+        if (parameters instanceof Array) {
+            for (var p = 0; p < parameters.length; ++p) {
+                if (parameters[p][0] == name) {
+                    if (value === undefined) {
+                        parameters.splice(p, 1);
+                    } else {
+                        parameters[p][1] = value;
+                        value = undefined;
+                    }
+                }
+            }
+            if (value !== undefined) {
+                parameters.push([name, value]);
+            }
+        } else {
+            parameters = OAuth.getParameterMap(parameters);
+            parameters[name] = value;
+            message.parameters = parameters;
+        }
+    }
+,
+    setParameters: function setParameters(message, parameters) {
+        var list = OAuth.getParameterList(parameters);
+        for (var i = 0; i < list.length; ++i) {
+            OAuth.setParameter(message, list[i][0], list[i][1]);
+        }
+    }
+,
+    /** Fill in parameters to help construct a request message.
+        This function doesn't fill in every parameter.
+        The accessor object should be like:
+        {consumerKey:'foo', consumerSecret:'bar', accessorSecret:'nurn', token:'krelm', tokenSecret:'blah'}
+        The accessorSecret property is optional.
+     */
+    completeRequest: function completeRequest(message, accessor) {
+        if (message.method == null) {
+            message.method = "GET";
+        }
+        var map = OAuth.getParameterMap(message.parameters);
+        if (map.oauth_consumer_key == null) {
+            OAuth.setParameter(message, "oauth_consumer_key", accessor.consumerKey || "");
+        }
+        if (map.oauth_token == null && accessor.token != null) {
+            OAuth.setParameter(message, "oauth_token", accessor.token);
+        }
+        if (map.oauth_version == null) {
+            OAuth.setParameter(message, "oauth_version", "1.0");
+        }
+        if (map.oauth_timestamp == null) {
+            OAuth.setParameter(message, "oauth_timestamp", OAuth.timestamp());
+        }
+        if (map.oauth_nonce == null) {
+            OAuth.setParameter(message, "oauth_nonce", OAuth.nonce(6));
+        }
+        OAuth.SignatureMethod.sign(message, accessor);
+    }
+,
+    setTimestampAndNonce: function setTimestampAndNonce(message) {
+        OAuth.setParameter(message, "oauth_timestamp", OAuth.timestamp());
+        OAuth.setParameter(message, "oauth_nonce", OAuth.nonce(6));
+    }
+,
+    addToURL: function addToURL(url, parameters) {
+        newURL = url;
+        if (parameters != null) {
+            var toAdd = OAuth.formEncode(parameters);
+            if (toAdd.length > 0) {
+                var q = url.indexOf('?');
+                if (q < 0) newURL += '?';
+                else       newURL += '&';
+                newURL += toAdd;
+            }
+        }
+        return newURL;
+    }
+,
+    /** Construct the value of the Authorization header for an HTTP request. */
+    getAuthorizationHeader: function getAuthorizationHeader(realm, parameters) {
+        var header = 'OAuth realm="' + OAuth.percentEncode(realm) + '"';
+        var list = OAuth.getParameterList(parameters);
+        for (var p = 0; p < list.length; ++p) {
+            var parameter = list[p];
+            var name = parameter[0];
+            if (name.indexOf("oauth_") == 0) {
+                header += ',' + OAuth.percentEncode(name) + '="' + OAuth.percentEncode(parameter[1]) + '"';
+            }
+        }
+        return header;
+    }
+,
+    timestamp: function timestamp() {
+        var d = new Date();
+        return Math.floor(d.getTime()/1000);
+    }
+,
+    nonce: function nonce(length) {
+        var chars = OAuth.nonce.CHARS;
+        var result = "";
+        for (var i = 0; i < length; ++i) {
+            var rnum = Math.floor(Math.random() * chars.length);
+            result += chars.substring(rnum, rnum+1);
+        }
+        return result;
+    }
+});
+
+OAuth.nonce.CHARS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXTZabcdefghiklmnopqrstuvwxyz";
+
+/** Define a constructor function,
+    without causing trouble to anyone who was using it as a namespace.
+    That is, if parent[name] already existed and had properties,
+    copy those properties into the new constructor.
+ */
+OAuth.declareClass = function declareClass(parent, name, newConstructor) {
+    var previous = parent[name];
+    parent[name] = newConstructor;
+    if (newConstructor != null && previous != null) {
+        for (var key in previous) {
+            if (key != "prototype") {
+                newConstructor[key] = previous[key];
+            }
+        }
+    }
+    return newConstructor;
+}
+
+/** An abstract algorithm for signing messages. */
+OAuth.declareClass(OAuth, "SignatureMethod", function OAuthSignatureMethod(){});
+
+OAuth.setProperties(OAuth.SignatureMethod.prototype, // instance members
+{
+    /** Add a signature to the message. */
+    sign: function sign(message) {
+        var baseString = OAuth.SignatureMethod.getBaseString(message);
+        var signature = this.getSignature(baseString);
+        OAuth.setParameter(message, "oauth_signature", signature);
+        return signature; // just in case someone's interested
+    }
+,
+    /** Set the key string for signing. */
+    initialize: function initialize(name, accessor) {
+        var consumerSecret;
+        if (accessor.accessorSecret != null
+            && name.length > 9
+            && name.substring(name.length-9) == "-Accessor")
+        {
+            consumerSecret = accessor.accessorSecret;
+        } else {
+            consumerSecret = accessor.consumerSecret;
+        }
+        this.key = OAuth.percentEncode(consumerSecret)
+             +"&"+ OAuth.percentEncode(accessor.tokenSecret);
+    }
+});
+
+/* SignatureMethod expects an accessor object to be like this:
+   {tokenSecret: "lakjsdflkj...", consumerSecret: "QOUEWRI..", accessorSecret: "xcmvzc..."}
+   The accessorSecret property is optional.
+ */
+// Class members:
+OAuth.setProperties(OAuth.SignatureMethod, // class members
+{
+    sign: function sign(message, accessor) {
+        var name = OAuth.getParameterMap(message.parameters).oauth_signature_method;
+        if (name == null || name == "") {
+            name = "HMAC-SHA1";
+            OAuth.setParameter(message, "oauth_signature_method", name);
+        }
+        OAuth.SignatureMethod.newMethod(name, accessor).sign(message);
+    }
+,
+    /** Instantiate a SignatureMethod for the given method name. */
+    newMethod: function newMethod(name, accessor) {
+        var impl = OAuth.SignatureMethod.REGISTERED[name];
+        if (impl != null) {
+            var method = new impl();
+            method.initialize(name, accessor);
+            return method;
+        }
+        var err = new Error("signature_method_rejected");
+        var acceptable = "";
+        for (var r in OAuth.SignatureMethod.REGISTERED) {
+            if (acceptable != "") acceptable += '&';
+            acceptable += OAuth.percentEncode(r);
+        }
+        err.oauth_acceptable_signature_methods = acceptable;
+        throw err;
+    }
+,
+    /** A map from signature method name to constructor. */
+    REGISTERED : {}
+,
+    /** Subsequently, the given constructor will be used for the named methods.
+        The constructor will be called with no parameters.
+        The resulting object should usually implement getSignature(baseString).
+        You can easily define such a constructor by calling makeSubclass, below.
+     */
+    registerMethodClass: function registerMethodClass(names, classConstructor) {
+        for (var n = 0; n < names.length; ++n) {
+            OAuth.SignatureMethod.REGISTERED[names[n]] = classConstructor;
+        }
+    }
+,
+    /** Create a subclass of OAuth.SignatureMethod, with the given getSignature function. */
+    makeSubclass: function makeSubclass(getSignatureFunction) {
+        var superClass = OAuth.SignatureMethod;
+        var subClass = function() {
+            superClass.call(this);
+        };
+        subClass.prototype = new superClass();
+        // Delete instance variables from prototype:
+        // delete subclass.prototype... There aren't any.
+        subClass.prototype.getSignature = getSignatureFunction;
+        subClass.prototype.constructor = subClass;
+        return subClass;
+    }
+,
+    getBaseString: function getBaseString(message) {
+        var URL = message.action;
+        var q = URL.indexOf('?');
+        var parameters;
+        if (q < 0) {
+            parameters = message.parameters;
+        } else {
+            // Combine the URL query string with the other parameters:
+            parameters = OAuth.decodeForm(URL.substring(q + 1));
+            var toAdd = OAuth.getParameterList(message.parameters);
+            for (var a = 0; a < toAdd.length; ++a) {
+                parameters.push(toAdd[a]);
+            }
+        }
+        return OAuth.percentEncode(message.method.toUpperCase())
+         +'&'+ OAuth.percentEncode(OAuth.SignatureMethod.normalizeUrl(URL))
+         +'&'+ OAuth.percentEncode(OAuth.SignatureMethod.normalizeParameters(parameters));
+    }
+,
+    normalizeUrl: function normalizeUrl(url) {
+        var uri = OAuth.SignatureMethod.parseUri(url);
+        var scheme = uri.protocol.toLowerCase();
+        var authority = uri.authority.toLowerCase();
+        var dropPort = (scheme == "http" && uri.port == 80)
+                    || (scheme == "https" && uri.port == 443);
+        if (dropPort) {
+            // find the last : in the authority
+            var index = authority.lastIndexOf(":");
+            if (index >= 0) {
+                authority = authority.substring(0, index);
+            }
+        }
+        var path = uri.path;
+        /* This actually produces different signatures from the python lib
+        if (!path) {
+            path = "/"; // conforms to RFC 2616 section 3.2.2
+        }
+         */
+        // we know that there is no query and no fragment here.
+        return scheme + "://" + authority + path;
+    }
+,
+    parseUri: function parseUri (str) {
+        /* This function was adapted from parseUri 1.2.1
+           http://stevenlevithan.com/demo/parseuri/js/assets/parseuri.js
+         */
+        var o = {key: ["source","protocol","authority","userInfo","user","password","host","port","relative","path","directory","file","query","anchor"],
+                 parser: {strict: /^(?:([^:\/?#]+):)?(?:\/\/((?:(([^:@]*):?([^:@]*))?@)?([^:\/?#]*)(?::(\d*))?))?((((?:[^?#\/]*\/)*)([^?#]*))(?:\?([^#]*))?(?:#(.*))?)/ }};
+        var m = o.parser.strict.exec(str);
+        var uri = {};
+        var i = 14;
+        while (i--) uri[o.key[i]] = m[i] || "";
+        return uri;
+    }
+,
+    normalizeParameters: function normalizeParameters(parameters) {
+        if (parameters == null) {
+            return "";
+        }
+        var list = OAuth.getParameterList(parameters);
+        var sortable = [];
+        for (var p = 0; p < list.length; ++p) {
+            var nvp = list[p];
+            if (nvp[0] == "oauth_signature" || nvp[0] == "realm") {
+                continue;
+            } else {
+                sortable.push([ OAuth.percentEncode(nvp[0])
+                              + " " // because it comes before any character that can appear in a percentEncoded string.
+                              + OAuth.percentEncode(nvp[1])
+                              , nvp]);
+            }
+        }
+        sortable.sort(function(a,b) {
+                          if (a[0] < b[0]) return  -1;
+                          if (a[0] > b[0]) return 1;
+                          return 0;
+                      });
+        var sorted = [];
+        for (var s = 0; s < sortable.length; ++s) {
+            sorted.push(sortable[s][1]);
+        }
+        return OAuth.formEncode(sorted);
+    }
+});
+
+OAuth.SignatureMethod.registerMethodClass(["PLAINTEXT", "PLAINTEXT-Accessor"],
+    OAuth.SignatureMethod.makeSubclass(
+        function getSignature(baseString) {
+            return this.key;
+        }
+    ));
+
+OAuth.SignatureMethod.registerMethodClass(["HMAC-SHA1", "HMAC-SHA1-Accessor"],
+    OAuth.SignatureMethod.makeSubclass(
+        function getSignature(baseString) {
+            b64pad = '=';
+            var signature = b64_hmac_sha1(this.key, baseString);
+            return signature;
+        }
+    ));
 
=== added file 'content/sha1.js'
--- content/sha1.js	1970-01-01 00:00:00 +0000
+++ content/sha1.js	2009-09-02 17:07:11 +0000
@@ -0,0 +1,202 @@
+/*
+ * A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined
+ * in FIPS PUB 180-1
+ * Version 2.1a Copyright Paul Johnston 2000 - 2002.
+ * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet
+ * Distributed under the BSD License
+ * See http://pajhome.org.uk/crypt/md5 for details.
+ */
+
+/*
+ * Configurable variables. You may need to tweak these to be compatible with
+ * the server-side, but the defaults work in most cases.
+ */
+var hexcase = 0;  /* hex output format. 0 - lowercase; 1 - uppercase        */
+var b64pad  = ""; /* base-64 pad character. "=" for strict RFC compliance   */
+var chrsz   = 8;  /* bits per input character. 8 - ASCII; 16 - Unicode      */
+
+/*
+ * These are the functions you'll usually want to call
+ * They take string arguments and return either hex or base-64 encoded strings
+ */
+function hex_sha1(s){return binb2hex(core_sha1(str2binb(s),s.length * chrsz));}
+function b64_sha1(s){return binb2b64(core_sha1(str2binb(s),s.length * chrsz));}
+function str_sha1(s){return binb2str(core_sha1(str2binb(s),s.length * chrsz));}
+function hex_hmac_sha1(key, data){ return binb2hex(core_hmac_sha1(key, data));}
+function b64_hmac_sha1(key, data){ return binb2b64(core_hmac_sha1(key, data));}
+function str_hmac_sha1(key, data){ return binb2str(core_hmac_sha1(key, data));}
+
+/*
+ * Perform a simple self-test to see if the VM is working
+ */
+function sha1_vm_test()
+{
+  return hex_sha1("abc") == "a9993e364706816aba3e25717850c26c9cd0d89d";
+}
+
+/*
+ * Calculate the SHA-1 of an array of big-endian words, and a bit length
+ */
+function core_sha1(x, len)
+{
+  /* append padding */
+  x[len >> 5] |= 0x80 << (24 - len % 32);
+  x[((len + 64 >> 9) << 4) + 15] = len;
+
+  var w = Array(80);
+  var a =  1732584193;
+  var b = -271733879;
+  var c = -1732584194;
+  var d =  271733878;
+  var e = -1009589776;
+
+  for(var i = 0; i < x.length; i += 16)
+  {
+    var olda = a;
+    var oldb = b;
+    var oldc = c;
+    var oldd = d;
+    var olde = e;
+
+    for(var j = 0; j < 80; j++)
+    {
+      if(j < 16) w[j] = x[i + j];
+      else w[j] = rol(w[j-3] ^ w[j-8] ^ w[j-14] ^ w[j-16], 1);
+      var t = safe_add(safe_add(rol(a, 5), sha1_ft(j, b, c, d)),
+                       safe_add(safe_add(e, w[j]), sha1_kt(j)));
+      e = d;
+      d = c;
+      c = rol(b, 30);
+      b = a;
+      a = t;
+    }
+
+    a = safe_add(a, olda);
+    b = safe_add(b, oldb);
+    c = safe_add(c, oldc);
+    d = safe_add(d, oldd);
+    e = safe_add(e, olde);
+  }
+  return Array(a, b, c, d, e);
+
+}
+
+/*
+ * Perform the appropriate triplet combination function for the current
+ * iteration
+ */
+function sha1_ft(t, b, c, d)
+{
+  if(t < 20) return (b & c) | ((~b) & d);
+  if(t < 40) return b ^ c ^ d;
+  if(t < 60) return (b & c) | (b & d) | (c & d);
+  return b ^ c ^ d;
+}
+
+/*
+ * Determine the appropriate additive constant for the current iteration
+ */
+function sha1_kt(t)
+{
+  return (t < 20) ?  1518500249 : (t < 40) ?  1859775393 :
+         (t < 60) ? -1894007588 : -899497514;
+}
+
+/*
+ * Calculate the HMAC-SHA1 of a key and some data
+ */
+function core_hmac_sha1(key, data)
+{
+  var bkey = str2binb(key);
+  if(bkey.length > 16) bkey = core_sha1(bkey, key.length * chrsz);
+
+  var ipad = Array(16), opad = Array(16);
+  for(var i = 0; i < 16; i++)
+  {
+    ipad[i] = bkey[i] ^ 0x36363636;
+    opad[i] = bkey[i] ^ 0x5C5C5C5C;
+  }
+
+  var hash = core_sha1(ipad.concat(str2binb(data)), 512 + data.length * chrsz);
+  return core_sha1(opad.concat(hash), 512 + 160);
+}
+
+/*
+ * Add integers, wrapping at 2^32. This uses 16-bit operations internally
+ * to work around bugs in some JS interpreters.
+ */
+function safe_add(x, y)
+{
+  var lsw = (x & 0xFFFF) + (y & 0xFFFF);
+  var msw = (x >> 16) + (y >> 16) + (lsw >> 16);
+  return (msw << 16) | (lsw & 0xFFFF);
+}
+
+/*
+ * Bitwise rotate a 32-bit number to the left.
+ */
+function rol(num, cnt)
+{
+  return (num << cnt) | (num >>> (32 - cnt));
+}
+
+/*
+ * Convert an 8-bit or 16-bit string to an array of big-endian words
+ * In 8-bit function, characters >255 have their hi-byte silently ignored.
+ */
+function str2binb(str)
+{
+  var bin = Array();
+  var mask = (1 << chrsz) - 1;
+  for(var i = 0; i < str.length * chrsz; i += chrsz)
+    bin[i>>5] |= (str.charCodeAt(i / chrsz) & mask) << (32 - chrsz - i%32);
+  return bin;
+}
+
+/*
+ * Convert an array of big-endian words to a string
+ */
+function binb2str(bin)
+{
+  var str = "";
+  var mask = (1 << chrsz) - 1;
+  for(var i = 0; i < bin.length * 32; i += chrsz)
+    str += String.fromCharCode((bin[i>>5] >>> (32 - chrsz - i%32)) & mask);
+  return str;
+}
+
+/*
+ * Convert an array of big-endian words to a hex string.
+ */
+function binb2hex(binarray)
+{
+  var hex_tab = hexcase ? "0123456789ABCDEF" : "0123456789abcdef";
+  var str = "";
+  for(var i = 0; i < binarray.length * 4; i++)
+  {
+    str += hex_tab.charAt((binarray[i>>2] >> ((3 - i%4)*8+4)) & 0xF) +
+           hex_tab.charAt((binarray[i>>2] >> ((3 - i%4)*8  )) & 0xF);
+  }
+  return str;
+}
+
+/*
+ * Convert an array of big-endian words to a base-64 string
+ */
+function binb2b64(binarray)
+{
+  var tab = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+  var str = "";
+  for(var i = 0; i < binarray.length * 4; i += 3)
+  {
+    var triplet = (((binarray[i   >> 2] >> 8 * (3 -  i   %4)) & 0xFF) << 16)
+                | (((binarray[i+1 >> 2] >> 8 * (3 - (i+1)%4)) & 0xFF) << 8 )
+                |  ((binarray[i+2 >> 2] >> 8 * (3 - (i+2)%4)) & 0xFF);
+    for(var j = 0; j < 4; j++)
+    {
+      if(i * 8 + j * 6 > binarray.length * 32) str += b64pad;
+      else str += tab.charAt((triplet >> 6*(3-j)) & 0x3F);
+    }
+  }
+  return str;
+}
 
=== modified file 'content/sync.js'
--- content/sync.js	2009-08-27 18:45:48 +0000
+++ content/sync.js	2009-09-08 15:29:55 +0000
@@ -112,11 +112,11 @@
            .getService(Components.interfaces.nsIWindowMediator)
            .getEnumerator("").getNext() == window) {
             Bindwood.writeMessage("First window opened. Getting a Couch Port");
-            Bindwood.getCouchPortNumber(Bindwood.startProcess);
+            Bindwood.getCouchEnvironment(Bindwood.startProcess);
         }
     },
 
-    getCouchPortNumber: function(continueFunction) {
+    getCouchEnvironment: function(continueFunction) {
         // find the desktop Couch port number by making a D-Bus call
         // we call D-Bus by shelling out to a bash script which calls
         // it for us, and writes the port number into a temp file
@@ -139,12 +139,12 @@
         var MY_ID = "[e-mail]";
         var em = Components.classes["@mozilla.org/extensions/manager;1"].
             getService(Components.interfaces.nsIExtensionManager);
-        var dbus_script = em.getInstallLocation(MY_ID).getItemFile(MY_ID, "dbus.sh");
-        Bindwood.writeMessage("Found path to dbus_script: " + dbus_script.path);
+        var couchdb_env_script = em.getInstallLocation(MY_ID).getItemFile(MY_ID, "couchdb_env.sh");
+        Bindwood.writeMessage("Found path to dbus_script: " + couchdb_env_script.path);
         // create an nsILocalFile for the executable
         var nsifile = Components.classes["@mozilla.org/file/local;1"]
                      .createInstance(Components.interfaces.nsILocalFile);
-        nsifile.initWithPath(dbus_script.path);
+        nsifile.initWithPath(couchdb_env_script.path);
 
         // create an nsIProcess2 to execute this bash script
         var process = Components.classes["@mozilla.org/process/util;1"]
@@ -153,14 +153,16 @@
 
         // Run the process, passing the tmpfile path
         var args = [tmpfile.path];
-        Bindwood.writeMessage("Running dbus script");
+        Bindwood.writeMessage("Running couchdb env script");
         process.runAsync(args, args.length, {
             observe: function(process, finishState, unused_data) {
-                var port = 5984;
+                // If the script exists cleanly, we should have a file
+                // containing the port couch is running on as well as
+                // the various OAuth tokens necessary to talk to it.
                 if (finishState == "process-finished") {
-                    // read temp file to find port number
+                    // read temp file to find couch environment
                     // https://developer.mozilla.org/en/Code_snippets/File_I%2f%2fO#Reading_from_a_file
-                    var data = "";
+                    var environment;
                     var fstream = Components.classes["@mozilla.org/network/file-input-stream;1"].
                         createInstance(Components.interfaces.nsIFileInputStream);
                     var cstream = Components.classes["@mozilla.org/intl/converter-input-stream;1"].
@@ -169,28 +171,56 @@
                     cstream.init(fstream, "UTF-8", 0, 0);
                     let (str = {}) {
                       cstream.readString(-1, str); // read the whole file and put it in str.value
-                      data = str.value;
+                      environment = str.value;
                     };
                     cstream.close(); // this closes fstream
-                    data = data.replace(/^\s\s*/, '').replace(/\s\s*$/, '');
-                    if (/^[0-9]+$/.test(data)) {
-                        port = data;
-                    } else {
-                        Bindwood.writeMessage("D-Bus port data is not a number (" + data + ")");
-                    }
+                    environment = environment.replace(/^\s\s*/, '').replace(/\s\s*$/, '');
                 } else {
                     // fall back to system CouchDB
                     Bindwood.writeMessage("D-Bus port find failed");
                 }
                 tmpfile.remove(false);
-                continueFunction(port);
-        }
+
+                if (environment == 'ENOCOUCH') {
+                    // No Couch environment found. Just spit out a
+                    // message and return, stopping Bindwood from
+                    // doing anything further.
+                    Bindwood.writeError("No suitable Couch environment found. Not proceeding.", e);
+                } else {
+                    // If we don't have a Couch environment, don't bother
+                    // trying to fall back on the system CouchDB.
+                    continueFunction(environment);
+                }
+            }
         });
     },
 
-    startProcess: function(couchPortNumber) {
-        Bindwood.writeMessage("Starting process with Couch on port " + couchPortNumber);
-        CouchDB.PORT_NUMBER = couchPortNumber;
+    startProcess: function(couchEnvironment) {
+        Bindwood.writeMessage("Starting process with Couch environment: " + couchEnvironment);
+
+        var env_array = couchEnvironment.split(':');
+        var port = env_array[0];
+        var consumer_key = env_array[1];
+        var consumer_secret = env_array[2];
+        var token = env_array[3];
+        var token_secret = env_array[4];
+
+        CouchDB.port = port;
+        CouchDB.accessor = {
+            consumerSecret: consumer_secret,
+            tokenSecret: token_secret
+        };
+        CouchDB.message = {
+            parameters: {
+                oauth_callback: "None",
+                oauth_consumer_key: consumer_key,
+                oauth_signature_method: "HMAC-SHA1",
+                oauth_token: token,
+                oauth_verifier: "None",
+                oauth_version: "1.0"
+            }
+        };
+
         try {
             Bindwood.writeMessage("Pushing bookmarks");
             Bindwood.pushBookmarks();
@@ -260,10 +290,19 @@
             }
         }
 
-        Bindwood.pushBookmarksFromList(Bindwood.bookmarksService.toolbarFolder,
-            "toolbarFolder", couch);
-        Bindwood.pushBookmarksFromList(Bindwood.bookmarksService.bookmarksMenuFolder,
-            "bookmarksMenuFolder", couch);
+        try {
+            Bindwood.pushBookmarksFromList(Bindwood.bookmarksService.toolbarFolder,
+                                           "toolbarFolder", couch);
+        } catch(e) {
+            Bindwood.writeError("Error pushing toolbarFolder bookmarks: ", e);
+        }
+
+        try {
+            Bindwood.pushBookmarksFromList(Bindwood.bookmarksService.bookmarksMenuFolder,
+                                           "bookmarksMenuFolder", couch);
+        } catch(e) {
+            Bindwood.writeError("Error pushing bookmarksMenuFolder bookmarks: ", e);
+        }
     },
 
     getBookmarksFromList: function(bookmarksList) {
@@ -320,15 +359,19 @@
 
             Bindwood.uuidItemIdMap[uuid] = itemId;
 
-            var results = db.query(function(doc) {
-                if (doc.application_annotations &&
-                    doc.application_annotations.Firefox &&
-                    doc.application_annotations.Firefox.uuid) {
-                    emit(doc.application_annotations.Firefox.uuid, doc);
-                }
-            }, null, {
-                startkey: uuid, endkey: uuid
-            });
+            try {
+                var results = db.query(function(doc) {
+                                           if (doc.application_annotations &&
+                                               doc.application_annotations.Firefox &&
+                                               doc.application_annotations.Firefox.uuid) {
+                                               emit(doc.application_annotations.Firefox.uuid, doc);
+                                           }
+                                       }, null, {
+                                           startkey: uuid, endkey: uuid
+                                       });
+            } catch(e) {
+                Bindwood.writeError("Error querying couch: ", e);
+            }
 
             if (results.rows.length === 0) {
                 // this bookmark is not in CouchDB, so write it
@@ -440,7 +483,7 @@
                             Bindwood.writeMessage("The URI from Couch (" + bm.uri + ") is different from local (" + metadata.spec + ")");
                             try {
                                 var new_uri = Bindwood.ioService.newURI(bm.uri, null, null);
-                                Bindowod.writeMessage("Creating a new URI for our local bookmark");
+                                Bindwood.writeMessage("Creating a new URI for our local bookmark");
                                 Bindwood.bookmarksService.changeBookmarkURI(itemId, new_uri);
                             } catch(e) {
                                 Bindwood.writeError("Problem creating a new URI for bookmark: ", e);
@@ -482,7 +525,7 @@
 
         try {
             var new_uri = Bindwood.ioService.newURI(bm.uri, null, null);
-            Bindowod.writeMessage("Creating a new URI for our local bookmark");
+            Bindwood.writeMessage("Creating a new URI for our local bookmark");
             Bindwood.bookmarksService.changeBookmarkURI(itemId, new_uri);
         } catch(e) {
             Bindwood.writeError("Problem creating a new URI for bookmark: ", e);
 
=== renamed file 'dbus.sh' => 'couchdb_env.sh'
--- dbus.sh	2009-08-18 14:17:30 +0000
+++ couchdb_env.sh	2009-09-01 19:40:34 +0000
@@ -13,12 +13,16 @@
 # You should have received a copy of the GNU General Public License along
 # with this program.  If not, see <http://www.gnu.org/licenses/>.
 OUT=$1
-PORT=$(dbus-send --session --dest=org.desktopcouch.CouchDB --print-reply --type=method_call / org.desktopcouch.CouchDB.getPort 2>/dev/null | grep int32 | awk '{print $2}' )
+
+PORT=$(dbus-send --session --dest=org.desktopcouch.CouchDB --print-reply --type=method_call / org.desktopcouch.CouchDB.getPort 2>/dev/null | grep int32 | awk '{print $2}')
+
+TOKENS=$(python -c "import gnomekeyring; print gnomekeyring.find_items_sync(gnomekeyring.ITEM_GENERIC_SECRET, {'desktopcouch': 'oauth'})[0].secret" 2>/dev/null)
+
 if [ -z "$PORT" ]; then
-  # D-Bus call failed for some reason, so use default port
-  echo 5984 > $OUT
+  # D-Bus call failed for some reason, so just punt
+  echo ENOCOUCH > $OUT
 else
-  echo $PORT > $OUT
+  echo $PORT:$TOKENS > $OUT
 fi