citeclaw 2.0.0

package/LICENSE

@@ -0,0 +1,202 @@
+Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   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.
+

package/README.md

@@ -0,0 +1,152 @@
+# CiteClaw
+
+`CiteClaw` is a citation and bibliography toolkit built on top of Wikimedia Citoid, Crossref, Semantic Scholar, and Zotero-oriented workflows.
+
+It is designed for two related jobs:
+
+- fast citation resolution from DOI, URL, arXiv, anthology pages, and PDFs
+- larger bibliography workflows such as cleaning BibTeX, expanding literature coverage, and maintaining Zotero-backed reference sets
+
+## What It Does
+
+`CiteClaw` combines:
+
+- a CLI for citation lookup, metadata export, PDF resolution, and batch jobs
+- an HTTP service compatible with Citoid-style API flows
+- an MCP server mode for agent/tool integrations
+- Zotero automation for query, cite, add, update, notes, dedup, enrichment, and export
+- vendored translator and CSL style assets for reproducible local runs
+
+## Fast Start
+
+Run directly from GitHub:
+
+```bash
+npx github:trotsky1997/citeclaw#master --help
+npx github:trotsky1997/citeclaw#master citoid formats
+npx github:trotsky1997/citeclaw#master cite bibtex 10.48550/arXiv.1706.03762
+npx github:trotsky1997/citeclaw#master crossref "10.1021/acsomega.2c05310"
+```
+
+Typical resolution flows:
+
+```bash
+npx github:trotsky1997/citeclaw#master citoid bibtex "10.1145/3589334.3648158"
+npx github:trotsky1997/citeclaw#master citoid bibtex "https://arxiv.org/abs/2305.19860"
+npx github:trotsky1997/citeclaw#master citoid bibtex "https://aclanthology.org/2023.emnlp-main.398/"
+npx github:trotsky1997/citeclaw#master cite mediawiki "https://arxiv.org/abs/1706.03762"
+```
+
+## Local Service
+
+Install dependencies and start the service:
+
+```bash
+npm install
+npm run start -- -c config.dev.yaml
+```
+
+Then open:
+
+- API docs: `http://localhost:1970/?doc`
+- OpenAPI spec: `http://localhost:1970/?spec`
+- Service info: `http://localhost:1970/_info`
+
+The service layer is still based on the Wikimedia Citoid architecture:
+
+- homepage: <https://www.mediawiki.org/wiki/Citoid>
+- HTTP entrypoints: [server.js](/mnt/e/botcite/server.js), [app.js](/mnt/e/botcite/app.js)
+
+## MCP Mode
+
+Start the MCP server over stdio:
+
+```bash
+npx github:trotsky1997/citeclaw#master mcp
+```
+
+Implemented methods:
+
+- `initialize`
+- `ping`
+- `tools/list`
+- `tools/call`
+
+Exposed tools:
+
+- `cite`
+- `cite_pdf`
+- `fetch_pdf`
+- `openurl_resolve`
+- `citoid`
+- `crossref`
+- `semantic_scholar`
+- `semantic_scholar_api`
+
+## Zotero Workflows
+
+Identity and login:
+
+```bash
+npx github:trotsky1997/citeclaw#master zotero whoami --api-key <zotero_api_key>
+npx github:trotsky1997/citeclaw#master zotero login --api-key <zotero_api_key>
+```
+
+Core item operations:
+
+```bash
+npx github:trotsky1997/citeclaw#master zotero query "transformer" --limit 20
+npx github:trotsky1997/citeclaw#master zotero cite AB12CD34
+npx github:trotsky1997/citeclaw#master zotero add '{"itemType":"journalArticle","title":"Demo"}'
+npx github:trotsky1997/citeclaw#master zotero update AB12CD34 '{"title":"Updated title"}'
+```
+
+Note and maintenance operations:
+
+```bash
+npx github:trotsky1997/citeclaw#master zotero note add AB12CD34 "<p>Key takeaway: ...</p>"
+npx github:trotsky1997/citeclaw#master zotero dedup --limit 300
+npx github:trotsky1997/citeclaw#master zotero enrich --apply
+npx github:trotsky1997/citeclaw#master zotero export md --out ./library.md
+```
+
+Safety defaults:
+
+- destructive deletes require confirmation unless `-y`
+- `update` and `delete` use version preconditions
+- `safe-mode` and `--dry-run` are available for write protection
+
+## Bibliography Curation
+
+This repo includes a higher-level bibliography workflow skill:
+
+- [SKILL.md](/mnt/e/botcite/.skills/citeclaw-bibliography-curation/SKILL.md)
+
+Use it when the task is broader than “generate one citation”, for example:
+
+- clean a noisy `.bib`
+- expand a survey bibliography to dozens or hundreds of references
+- split core references from supplemental references
+- build a topic-wise literature map for an appendix
+
+## Development
+
+Useful commands:
+
+```bash
+npm run test
+npm run test:zotero
+npm run coverage
+npm run lint
+npm run pack:dry-run
+```
+
+Current package metadata and entrypoints live in:
+
+- [package.json](/mnt/e/botcite/package.json)
+- [scripts/citeclaw.js](/mnt/e/botcite/scripts/citeclaw.js)
+
+## Notes
+
+- The npm package name and primary CLI are `citeclaw`.
+- Repository URLs and examples now use `trotsky1997/citeclaw`.

package/app.js

@@ -0,0 +1,318 @@
+'use strict';
+
+const http = require( 'http' );
+const BBPromise = require( 'bluebird' );
+const express = require( 'express' );
+const compression = require( 'compression' );
+const bodyParser = require( 'body-parser' );
+const fs = BBPromise.promisifyAll( require( 'fs' ) );
+const sUtil = require( './lib/util' );
+const apiUtil = require( './lib/api-util' );
+const packageInfo = require( './package.json' );
+const yaml = require( 'js-yaml' );
+const addShutdown = require( 'http-shutdown' );
+const path = require( 'path' );
+const OutgoingRequestThrottle = require( './lib/OutgoingRequestThrottle' );
+
+/**
+ * Creates an express app and initialises it
+ *
+ * @param {Object} options the options to initialise the app with
+ * @return {bluebird} the promise resolving to the app object
+ */
+function initApp( options ) {
+
+	// the main application object
+	const app = express();
+
+	// get the options and make them available in the app
+	// the logging device
+	app.logger = options.logger;
+	// Add custom serialisers to the native bunyan logger
+	app.logger._logger.addSerializers( {
+		err: sUtil.errForLog,
+		outgoingReqResult: sUtil.outgoingReqResult,
+		uri: sUtil.uriForLog,
+		cr: sUtil.crForLog
+	} );
+
+	// the metrics
+	app.metrics = options.metrics;
+	// this app's config options
+	app.conf = options.config;
+	// this app's package info
+	app.info = packageInfo;
+
+	app.conf.userAgent = app.conf.user_agent || app.conf.userAgent || `Citoid/${ app.info.version }`;
+
+	// backwards compatibility for configurations which predate use of 'zotero' keyword in conf
+	if ( app.conf.zotero === undefined ) {
+		app.conf.zotero = true;
+	}
+	// backwards compatibility for configurations which predate use of 'pubmed' keyword in conf
+	if ( app.conf.pubmed === undefined ) {
+		app.conf.pubmed = true;
+	}
+
+	// ensure some reasonable defaults
+	if ( app.conf.port === undefined || app.conf.port === null ) {
+		app.conf.port = 1970;
+	}
+	if ( !app.conf.interface ) {
+		app.conf.interface = '0.0.0.0';
+	}
+	if ( app.conf.compression_level === undefined ) {
+		app.conf.compression_level = 3;
+	}
+	if ( app.conf.cors === undefined ) {
+		app.conf.cors = '*';
+	}
+	if ( app.conf.csp === undefined ) {
+		app.conf.csp = "default-src 'self'; object-src 'none'; media-src *; img-src *; style-src *; frame-ancestors 'self'";
+	}
+	if ( app.conf.outgoing_request_throttle === undefined ) {
+		app.conf.outgoing_request_throttle = {
+			enabled: true,
+			delayMs: 3100,
+			skipHosts: [ 'localhost', '127.0.0.1', '::1' ]
+		};
+	}
+	app.conf.outgoing_request_throttle.skipHosts = Array.from( new Set( [
+		...( app.conf.outgoing_request_throttle.skipHosts || [] ),
+		app.conf.zoteroInterface
+	].filter( Boolean ) ) );
+
+	// check the zotero configuration
+	if ( app.conf.zotero && !( app.conf.zoteroInterface && app.conf.zoteroPort ) ) {
+		throw new Error( 'Zotero IP/host or port not set' );
+	}
+
+	// set outgoing proxy
+	if ( app.conf.proxy ) {
+		process.env.HTTP_PROXY = app.conf.proxy;
+		// if there is a list of domains which should
+		// not be proxied, set it
+		if ( app.conf.no_proxy_list ) {
+			if ( Array.isArray( app.conf.no_proxy_list ) ) {
+				process.env.NO_PROXY = app.conf.no_proxy_list.join( ',' );
+			} else {
+				process.env.NO_PROXY = app.conf.no_proxy_list;
+			}
+		}
+		if ( !app.conf.zoteroUseProxy ) {
+			// don't use proxy for accessing Zotero unless specified in settings
+			if ( process.env.NO_PROXY ) {
+				process.env.NO_PROXY += ',';
+			} else {
+				process.env.NO_PROXY = '';
+			}
+			process.env.NO_PROXY += app.conf.zoteroInterface;
+		}
+	}
+
+	// set up header whitelisting for logging
+	if ( !app.conf.log_header_whitelist ) {
+		app.conf.log_header_whitelist = [
+			'cache-control', 'content-type', 'content-length', 'if-match',
+			'user-agent', 'x-request-id'
+		];
+	}
+	// eslint-disable-next-line security/detect-non-literal-regexp
+	app.conf.log_header_whitelist = new RegExp( `^(?:${ app.conf.log_header_whitelist.map( ( item ) => item.trim() ).join( '|' ) })$`, 'i' );
+
+	// set up the request templates for the APIs
+	apiUtil.setupApiTemplates( app );
+
+	// set up the spec
+	if ( !app.conf.spec ) {
+		app.conf.spec = `${ __dirname }/spec.yaml`;
+	}
+	if ( app.conf.spec.constructor !== Object ) {
+		try {
+			app.conf.spec = yaml.load( fs.readFileSync( app.conf.spec ) );
+		} catch ( e ) {
+			app.logger.log( 'warn/spec', `Could not load the spec: ${ e }` );
+			app.conf.spec = {};
+		}
+	}
+	if ( !app.conf.spec.openapi ) {
+		app.conf.spec.openapi = '3.0.0';
+	}
+	if ( !app.conf.spec.info ) {
+		app.conf.spec.info = {
+			version: app.info.version,
+			title: app.info.name,
+			description: app.info.description
+		};
+	}
+	app.conf.spec.info.version = app.info.version;
+	if ( !app.conf.spec.paths ) {
+		app.conf.spec.paths = {};
+	}
+
+	// set the CORS and CSP headers
+	app.all( '/{*catchall}', ( req, res, next ) => {
+		if ( app.conf.cors !== false ) {
+			res.header( 'access-control-allow-origin', app.conf.cors );
+			res.header( 'access-control-allow-headers', 'accept, x-requested-with, content-type, user-agent, api-user-agent, accept-language, referer' );
+			res.header( 'access-control-expose-headers', 'etag' );
+		}
+		if ( app.conf.csp !== false ) {
+			res.header( 'x-xss-protection', '1; mode=block' );
+			res.header( 'x-content-type-options', 'nosniff' );
+			res.header( 'x-frame-options', 'SAMEORIGIN' );
+			res.header( 'content-security-policy', app.conf.csp );
+			res.header( 'x-content-security-policy', app.conf.csp );
+			res.header( 'x-webkit-csp', app.conf.csp );
+		}
+		// Required by api gateway
+		res.header( 'cache-control', 'private, max-age=0, s-maxage=0, must-revalidate' );
+		app.set( 'etag', true );
+
+		sUtil.initAndLogRequest( req, app );
+		next();
+	} );
+
+	// set up the user agent header string to use for requests
+	app.conf.user_agent = app.conf.user_agent || app.info.name;
+
+	// disable the X-Powered-By header
+	app.set( 'x-powered-by', false );
+	// disable the ETag header - users should provide them!
+	app.set( 'etag', false );
+	// enable compression
+	app.use( compression( { level: app.conf.compression_level } ) );
+	// use the JSON body parser
+	app.use( bodyParser.json( { limit: app.conf.max_body_size || '100kb' } ) );
+	// use the application/x-www-form-urlencoded parser
+	app.use( bodyParser.urlencoded( { extended: true } ) );
+	app.outgoingRequestThrottle = new OutgoingRequestThrottle( app.conf.outgoing_request_throttle );
+
+	// Catch URI decoding errors
+	app.use( ( err, req, res, next ) => {
+		if ( err instanceof URIError && err.message && err.message.includes( 'Failed to decode param' ) ) {
+			res.status( 400 ).type( 'application/json' );
+			res.send( { error: 'Invalid URL encoding in request parameters' } );
+			return;
+		}
+		next( err );
+	} );
+
+	return BBPromise.resolve( app );
+
+}
+
+/**
+ * Loads all routes declared in routes/ into the app
+ *
+ * @param {Application} app the application object to load routes into
+ * @param {string} dir routes folder
+ * @return {bluebird} a promise resolving to the app object
+ */
+function loadRoutes( app, dir ) {
+
+	// recursively load routes from .js files under routes/
+	return fs.readdirAsync( dir ).map( ( fname ) => BBPromise.try( () => {
+		let route;
+		const resolvedPath = path.resolve( dir, fname );
+		const isDirectory = fs.statSync( resolvedPath ).isDirectory();
+		if ( isDirectory ) {
+			loadRoutes( app, resolvedPath );
+		} else if ( /\.js$/.test( fname ) ) {
+			// import the route file
+			// eslint-disable-next-line security/detect-non-literal-require
+			route = require( `${ dir }/${ fname }` );
+			return route( app );
+		}
+		// import the route file
+		// eslint-disable-next-line security/detect-non-literal-require
+		route = require( `${ __dirname }/routes/${ fname }` );
+		return route( app );
+	} ).then( ( route ) => {
+		if ( route === undefined ) {
+			return undefined;
+		}
+		// check that the route exports the object we need
+		if ( route.constructor !== Object || !route.path || !route.router ||
+                !( route.api_version || route.skip_domain ) ) {
+			throw new TypeError( `routes/${ fname } does not export the correct object!` );
+		}
+		// normalise the path to be used as the mount point
+		if ( route.path[ 0 ] !== '/' ) {
+			route.path = `/${ route.path }`;
+		}
+		if ( route.path[ route.path.length - 1 ] !== '/' ) {
+			route.path = `${ route.path }/`;
+		}
+		if ( !route.skip_domain ) {
+			route.path = `/:domain/v${ route.api_version }${ route.path }`;
+		}
+		// wrap the route handlers with Promise.try() blocks
+		sUtil.wrapRouteHandlers( route, app );
+		// all good, use that route
+		app.use( route.path, route.router );
+	} ) ).then( () => {
+		// catch errors
+		sUtil.setErrorHandler( app );
+		// route loading is now complete, return the app object
+		return BBPromise.resolve( app );
+	} );
+
+}
+
+/**
+ * Creates and start the service's web server
+ *
+ * @param {Application} app the app object to use in the service
+ * @return {bluebird} a promise creating the web server
+ */
+function createServer( app ) {
+
+	// return a promise which creates an HTTP server,
+	// attaches the app to it, and starts accepting
+	// incoming client requests
+	let server;
+	return new BBPromise( ( resolve ) => {
+		server = http.createServer( app ).listen(
+			app.conf.port,
+			app.conf.interface,
+			resolve
+		);
+		server = addShutdown( server );
+	} ).then( () => {
+		app.logger.log( 'info',
+			`Worker ${ process.pid } listening on ${ app.conf.interface || '*' }:${ app.conf.port }` );
+
+		// Don't delay incomplete packets for 40ms (Linux default) on
+		// pipelined HTTP sockets. We write in large chunks or buffers, so
+		// lack of coalescing should not be an issue here.
+		server.on( 'connection', ( socket ) => {
+			socket.setNoDelay( true );
+		} );
+
+		return server;
+	} );
+
+}
+
+function buildApp( options ) {
+	return initApp( options )
+		.then( ( app ) => loadRoutes( app, `${ __dirname }/routes` ) )
+		.then( ( app ) => {
+			app.use( '/static', express.static( `${ __dirname }/static` ) );
+			return app;
+		} );
+}
+
+/**
+ * The service's entry point. It takes over the configuration
+ * options and the logger- and metrics-reporting objects from
+ * service-runner and starts an HTTP server, attaching the application
+ * object to it.
+ *
+ * @param {Object} options
+ * @return {bluebird}
+ */
+module.exports = ( options ) => buildApp( options ).then( createServer );
+module.exports.buildApp = buildApp;
+module.exports.createServer = createServer;