code-server/src/node/entry.ts

145 lines
5.0 KiB
TypeScript
Raw Normal View History

2020-02-19 01:24:12 +07:00
import { field, logger } from "@coder/logger"
import * as cp from "child_process"
import * as path from "path"
import { CliMessage } from "../../lib/vscode/src/vs/server/ipc"
import { ApiHttpProvider } from "./app/api"
import { MainHttpProvider } from "./app/app"
import { LoginHttpProvider } from "./app/login"
2020-02-15 04:57:51 +07:00
import { UpdateHttpProvider } from "./app/update"
import { VscodeHttpProvider } from "./app/vscode"
2020-02-19 01:24:12 +07:00
import { Args, optionDescriptions, parse } from "./cli"
2020-02-05 02:27:46 +07:00
import { AuthType, HttpServer } from "./http"
import { generateCertificate, generatePassword, hash, open } from "./util"
import { ipcMain, wrap } from "./wrapper"
const main = async (args: Args): Promise<void> => {
2020-02-05 05:55:27 +07:00
const auth = args.auth || AuthType.Password
const originalPassword = auth === AuthType.Password && (process.env.PASSWORD || (await generatePassword()))
let commit: string | undefined
2020-02-05 07:16:45 +07:00
try {
commit = require("../../package.json").commit
} catch (error) {
logger.warn(error.message)
}
2020-02-05 02:27:46 +07:00
// Spawn the main HTTP server.
const options = {
2020-02-05 07:16:45 +07:00
auth,
2020-02-07 07:26:07 +07:00
cert: args.cert ? args.cert.value : undefined,
2020-02-05 02:27:46 +07:00
certKey: args["cert-key"],
commit: commit || "development",
2020-02-05 02:27:46 +07:00
host: args.host || (args.auth === AuthType.Password && typeof args.cert !== "undefined" ? "0.0.0.0" : "localhost"),
2020-02-05 07:16:45 +07:00
password: originalPassword ? hash(originalPassword) : undefined,
port: typeof args.port !== "undefined" ? args.port : process.env.PORT ? parseInt(process.env.PORT, 10) : 8080,
2020-02-05 02:27:46 +07:00
socket: args.socket,
}
2020-02-07 07:26:07 +07:00
if (!options.cert && args.cert) {
2020-02-05 02:27:46 +07:00
const { cert, certKey } = await generateCertificate()
options.cert = cert
options.certKey = certKey
} else if (args.cert && !args["cert-key"]) {
throw new Error("--cert-key is missing")
2020-02-05 02:27:46 +07:00
}
2020-02-05 07:16:45 +07:00
const httpServer = new HttpServer(options)
const api = httpServer.registerHttpProvider("/api", ApiHttpProvider, httpServer, args["user-data-dir"])
2020-02-15 04:57:51 +07:00
const update = httpServer.registerHttpProvider("/update", UpdateHttpProvider, !args["disable-updates"])
httpServer.registerHttpProvider("/vscode", VscodeHttpProvider, args)
httpServer.registerHttpProvider("/login", LoginHttpProvider)
2020-02-15 04:57:51 +07:00
httpServer.registerHttpProvider("/", MainHttpProvider, api, update)
2020-02-05 02:27:46 +07:00
ipcMain().onDispose(() => httpServer.dispose())
2020-02-05 02:27:46 +07:00
const serverAddress = await httpServer.listen()
logger.info(`Server listening on ${serverAddress}`)
if (auth === AuthType.Password && !process.env.PASSWORD) {
logger.info(` - Password is ${originalPassword}`)
logger.info(" - To use your own password, set the PASSWORD environment variable")
if (!args.auth) {
logger.info(" - To disable use `--auth none`")
}
} else if (auth === AuthType.Password) {
logger.info(" - Using custom password for authentication")
} else {
logger.info(" - No authentication")
}
if (httpServer.protocol === "https") {
logger.info(
2020-02-07 07:26:07 +07:00
typeof args.cert === "string"
? ` - Using provided certificate and key for HTTPS`
2020-02-15 07:46:00 +07:00
: ` - Using generated certificate and key for HTTPS`,
2020-02-05 02:27:46 +07:00
)
} else {
logger.info(" - Not serving HTTPS")
}
2020-02-15 04:57:51 +07:00
logger.info(` - Automatic updates are ${update.enabled ? "enabled" : "disabled"}`)
2020-02-05 02:27:46 +07:00
if (serverAddress && !options.socket && args.open) {
// The web socket doesn't seem to work if browsing with 0.0.0.0.
const openAddress = serverAddress.replace(/:\/\/0.0.0.0/, "://localhost")
await open(openAddress).catch(console.error)
logger.info(` - Opened ${openAddress}`)
}
}
const tryParse = (): Args => {
try {
return parse(process.argv.slice(2))
} catch (error) {
console.error(error.message)
process.exit(1)
}
}
const args = tryParse()
2020-02-07 07:26:07 +07:00
if (args.help) {
console.log("code-server", require("../../package.json").version)
console.log("")
console.log(`Usage: code-server [options] [path]`)
console.log("")
console.log("Options")
optionDescriptions().forEach((description) => {
console.log("", description)
})
} else if (args.version) {
const version = require("../../package.json").version
if (args.json) {
console.log({
codeServer: version,
vscode: require("../../lib/vscode/package.json").version,
})
} else {
console.log(version)
}
process.exit(0)
2020-02-19 01:24:12 +07:00
} else if (args["list-extensions"] || args["install-extension"] || args["uninstall-extension"]) {
logger.debug("forking vs code cli...")
2020-02-19 01:24:12 +07:00
const vscode = cp.fork(path.resolve(__dirname, "../../lib/vscode/out/vs/server/fork"), [], {
env: {
...process.env,
CODE_SERVER_PARENT_PID: process.pid.toString(),
},
})
vscode.once("message", (message) => {
logger.debug("Got message from VS Code", field("message", message))
if (message.type !== "ready") {
logger.error("Unexpected response waiting for ready response")
process.exit(1)
}
const send: CliMessage = { type: "cli", args }
vscode.send(send)
})
vscode.once("error", (error) => {
logger.error(error.message)
process.exit(1)
})
vscode.on("exit", (code) => process.exit(code || 0))
} else {
wrap(() => main(args))
}