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"
|
2020-02-14 05:38:05 +07:00
|
|
|
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"
|
2020-02-14 05:38:05 +07:00
|
|
|
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"
|
|
|
|
|
2020-02-07 01:29:19 +07:00
|
|
|
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()))
|
|
|
|
|
2020-02-06 03:21:59 +07:00
|
|
|
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"],
|
2020-02-06 03:21:59 +07:00
|
|
|
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,
|
2020-02-25 05:49:10 +07:00
|
|
|
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-25 03:55:17 +07:00
|
|
|
|
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
|
2020-02-25 03:55:17 +07:00
|
|
|
} 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)
|
2020-02-19 03:13:22 +07:00
|
|
|
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"])
|
2020-02-14 05:38:05 +07:00
|
|
|
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
|
|
|
|
2020-02-05 04:00:44 +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"
|
2020-02-25 03:55:17 +07:00
|
|
|
? ` - 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}`)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-02-20 00:14:50 +07:00
|
|
|
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) {
|
2020-02-05 04:00:44 +07:00
|
|
|
const version = require("../../package.json").version
|
2020-02-07 01:29:19 +07:00
|
|
|
if (args.json) {
|
2020-02-05 04:00:44 +07:00
|
|
|
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"]) {
|
2020-02-19 05:51:55 +07:00
|
|
|
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))
|
2020-02-05 04:00:44 +07:00
|
|
|
} else {
|
2020-02-07 01:29:19 +07:00
|
|
|
wrap(() => main(args))
|
2020-02-05 04:00:44 +07:00
|
|
|
}
|