@ordewell/web 0.10.2 → 0.10.4

package/dist/server/main.js

@@ -3,6 +3,7 @@
 
 var hono = require('hono');
 var child_process = require('child_process');
+var crypto = require('crypto');
 var core = require('@ordewell/core');
 var fs = require('fs');
 var path = require('path');
@@ -31,60 +32,59 @@ var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
 var path__namespace = /*#__PURE__*/_interopNamespace(path);
 
 var WebConfig = class extends core.BaseConfig {
-  _provider = null;
-  _providerCacheKey = null;
-  _providerCacheLists = void 0;
   _enabledRunnersOverride;
   _providerModelLists;
   _modelOverride;
+  _pickedModel;
+  _agentCatalog;
   constructor(opts) {
     super();
     this._enabledRunnersOverride = opts?.enabledRunners;
-    this._providerModelLists = opts?.providerModelLists;
+    const lists = opts?.providerModelLists;
+    this._providerModelLists = typeof lists === "function" ? lists : () => lists;
     this._modelOverride = opts?.modelOverride;
+    this._pickedModel = opts?.pickedModel ?? (() => void 0);
+    this._agentCatalog = opts?.agentCatalog ?? (() => []);
+  }
+  agentCatalog(provider) {
+    return this._agentCatalog(provider);
   }
   setProviderModelLists(lists) {
-    this._providerModelLists = lists;
-    this._provider = null;
+    this._providerModelLists = () => lists;
+  }
+  /**
+   * Read live, not fixed at construction: a session's WebConfig lives for the
+   * whole session while /model, /planner and /key mutate process.env under
+   * it. `routedProvider` keeps that cheap.
+   */
+  get planner() {
+    return this.resolvePlanner({ ...this.configuredPlanner(), override: this._modelOverride }, this._providerModelLists());
+  }
+  /**
+   * What the daemon inherited at startup, or what a settings write has set
+   * since; the model counts as picked only while it is the one a write picked.
+   */
+  configuredPlanner() {
+    const model = process.env.ORCHESTRATOR_MODEL || "";
+    const pick = this._pickedModel();
+    return { model, effort: process.env.ORDEWELL_PLANNER_EFFORT || "", pickedFor: pick?.model === model ? pick.provider : void 0 };
   }
   get orchestratorModel() {
-    return this._modelOverride || process.env.ORCHESTRATOR_MODEL || "";
+    return this.planner.model;
   }
   get aiProvider() {
-    const explicitEnv = process.env.AI_PROVIDER;
-    const model = this._modelOverride || process.env.ORCHESTRATOR_MODEL;
-    const cacheKey = `${explicitEnv ?? ""}|${model ?? ""}`;
-    if (this._provider && this._providerCacheKey === cacheKey && this._providerCacheLists === this._providerModelLists) {
-      return this._provider;
-    }
-    if (explicitEnv && core.isCliProvider(explicitEnv)) {
-      this._provider = explicitEnv;
-      this._providerCacheKey = cacheKey;
-      this._providerCacheLists = this._providerModelLists;
-      return this._provider;
-    }
-    if (model && this._providerModelLists) {
-      const resolved = core.resolveProvider(model, this._providerModelLists);
-      if (resolved) {
-        this._provider = resolved;
-        this._providerCacheKey = cacheKey;
-        this._providerCacheLists = this._providerModelLists;
-        return this._provider;
-      }
-    }
-    this._provider = core.BaseConfig.detectProvider("openrouter");
-    this._providerCacheKey = cacheKey;
-    this._providerCacheLists = this._providerModelLists;
-    return this._provider;
+    return this.planner.provider;
+  }
+  get plannerThinkingEffort() {
+    return this.planner.effort || void 0;
   }
   get apiKey() {
     const provider = this.aiProvider;
     return core.isApiProvider(provider) ? this.getProviderApiKey(provider) : "";
   }
   get planningModel() {
-    if (this.aiProvider === "google")
-      return core.normalizeGeminiModel(process.env.GEMINI_MODEL || process.env.ORCHESTRATOR_MODEL || super.geminiModel);
-    return process.env.ORCHESTRATOR_MODEL || "";
+    const model = this.plannerChoiceFor(this.aiProvider, this.configuredPlanner()).model;
+    return this.aiProvider === "google" ? core.normalizeGeminiModel(process.env.GEMINI_MODEL || model) : model;
   }
   get enabledRunners() {
     if (this._enabledRunnersOverride) return this._enabledRunnersOverride;
@@ -93,6 +93,8 @@ var WebConfig = class extends core.BaseConfig {
       const parsed = envRunners.split(",").map((s) => s.trim()).filter(Boolean);
       if (parsed.length > 0) return parsed;
     }
+    const toggles = ["ORDEWELL_CLAUDE_CODE_ENABLED", "ORDEWELL_CODEX_ENABLED", "ORDEWELL_OPENCODE_ENABLED"];
+    if (toggles.every((name) => process.env[name] === void 0)) return core.defaultEnabledRunners();
     const out = [];
     if (process.env.ORDEWELL_CLAUDE_CODE_ENABLED !== "false" && process.env.ORDEWELL_CLAUDE_CODE_ENABLED !== "0") {
       out.push("claude-code");
@@ -372,12 +374,26 @@ var PoolAwareRunner = class {
 var OrchestratorPool = class {
   sessions = /* @__PURE__ */ new Map();
   clients = /* @__PURE__ */ new Map();
+  /**
+   * This process's broadcast numbering (see `StreamStamp`), per session id
+   * rather than per Session object: a session replaced under the same id
+   * keeps counting up, so a client never mistakes its first broadcast for one
+   * of the old session's it already showed.
+   */
+  stream = crypto.randomUUID();
+  sequence = /* @__PURE__ */ new Map();
   registry = new core.RunnerRegistry();
   modelResolver;
-  runnerInstallation = new core.RunnerInstallation(this.registry);
+  runnerInstallation;
   cachedProviderLists;
   settingsService = new core.SettingsService();
   plannerModelMemory = new core.PlannerModelMemory(this.settingsService);
+  /**
+   * The model a settings write picked in this daemon. The environment's model
+   * is otherwise inherited, and an agent planning only because detection
+   * found it does not plan with an inherited model it cannot be shown to run.
+   */
+  pickedModel;
   runner;
   /** One probe per daemon, asked again whenever the runner list is refreshed (ADR-0033). */
   codexSandbox;
@@ -385,6 +401,7 @@ var OrchestratorPool = class {
     const pluginNotice = core.removedPluginNotice();
     if (pluginNotice) console.warn(pluginNotice);
     this.runner = deps.runner ?? new core.StructuredRunner();
+    this.runnerInstallation = deps.runnerInstallation ?? new core.RunnerInstallation(this.registry);
     this.modelResolver = deps.modelResolver ?? new core.ModelResolver(this.registry, new WebConfig());
     this.codexSandbox = deps.codexSandbox ?? new core.CodexSandboxAvailability(this.registry, { spawn: child_process.spawn, fetch: globalThis.fetch }, { cwd: process.cwd(), env: process.env });
   }
@@ -396,6 +413,29 @@ var OrchestratorPool = class {
   warmCodexSandbox() {
     this.codexSandbox.ensure().catch((err) => console.error(`[web] codex sandbox probe failed: ${err instanceof Error ? err.message : err}`));
   }
+  /**
+   * Find the coding agent that plans when the user has chosen no planner and
+   * set no vendor key (ADR-0009), for the daemon to start as it starts. Every
+   * planner turn waits on it, so a goal typed the instant the TUI opens
+   * does not plan with an openrouter key nobody set.
+   */
+  detectInstalledPlanner() {
+    return core.detectInstalledPlanner(this.runnerInstallation);
+  }
+  /**
+   * A new session's first planner turn. It waits for that probe at the
+   * session's own planner gate, where a reply sent meanwhile queues behind
+   * it, and a Stop or the session closing or being replaced ends the wait.
+   */
+  async firstTurn(sessionId, session, turn) {
+    try {
+      return await turn();
+    } catch (err) {
+      if (err instanceof core.PlannerNotReadyError && this.sessions.get(sessionId) === session) this.destroy(sessionId);
+      if (err instanceof core.PlannerTurnStoppedError && !session.planState) throw new core.PlannerTurnDiscardedError();
+      throw err;
+    }
+  }
   subscribe(sessionId, ws) {
     if (!this.clients.has(sessionId)) this.clients.set(sessionId, /* @__PURE__ */ new Set());
     this.clients.get(sessionId).add(ws);
@@ -405,7 +445,9 @@ var OrchestratorPool = class {
     if (this.clients.get(sessionId)?.size === 0) this.clients.delete(sessionId);
   }
   broadcast(sessionId, msg) {
-    const payload = JSON.stringify(msg);
+    const seq = (this.sequence.get(sessionId) ?? 0) + 1;
+    this.sequence.set(sessionId, seq);
+    const payload = JSON.stringify({ ...msg, stream: this.stream, seq });
     for (const ws of this.clients.get(sessionId) ?? []) {
       if (ws.readyState === ws.OPEN) ws.send(payload);
     }
@@ -444,6 +486,14 @@ var OrchestratorPool = class {
   runSnapshot(sessionId) {
     return this.sessions.get(sessionId)?.runSnapshot() ?? null;
   }
+  /** The planner's approval requests still waiting, as they were announced. */
+  announcedApprovals(sessionId) {
+    return this.sessions.get(sessionId)?.announcedApprovals() ?? [];
+  }
+  /** The last broadcast of the session so far: a snapshot taken now accounts for it and everything before. */
+  streamPosition(sessionId) {
+    return { stream: this.stream, seq: this.sequence.get(sessionId) ?? 0 };
+  }
   runtimeSettings() {
     return core.sessionRuntimeSettings(this.settingsService.getAll());
   }
@@ -456,11 +506,7 @@ var OrchestratorPool = class {
       core.ensureStateDirIgnored(workspace);
       core.assertWorkspaceIsProject(workspace);
     }
-    const config = new WebConfig({
-      enabledRunners: this.enabledRunnerOverride(),
-      modelOverride,
-      providerModelLists: this.cachedProviderLists
-    });
+    const config = this.plannerConfig(modelOverride);
     const fsAdapter = new PoolFileSystem(workspace);
     const broadcast = (msg) => this.broadcast(sessionId, msg);
     const runner = new PoolAwareRunner(sessionId, broadcast, this.runner);
@@ -484,6 +530,22 @@ var OrchestratorPool = class {
       sessionId
     });
   }
+  /**
+   * The one way the pool builds a config that answers "who plans": sessions,
+   * the settings response and the switch judgement all route through it, so
+   * what the settings route reports is what the next turn plans with. The
+   * lists are handed over as a reader, not a snapshot, so a credential change
+   * reaches a session that is already open.
+   */
+  plannerConfig(modelOverride) {
+    return new WebConfig({
+      enabledRunners: this.enabledRunnerOverride(),
+      modelOverride,
+      providerModelLists: () => this.cachedProviderLists,
+      pickedModel: () => this.pickedModel,
+      agentCatalog: (provider) => this.plannerCatalogFor(provider).map((model) => model.id)
+    });
+  }
   /**
    * The user's runner choice, or undefined when they have never made one —
    * which is what lets `WebConfig` fall back to the environment's defaults.
@@ -504,7 +566,7 @@ var OrchestratorPool = class {
     this.settingsService.setEnabledRunners(next);
   }
   getSettings() {
-    const config = new WebConfig({ enabledRunners: this.enabledRunnerOverride() });
+    const config = this.plannerConfig();
     const userSettings = this.settingsService.getAll();
     return {
       orchestratorModel: config.orchestratorModel,
@@ -555,21 +617,14 @@ var OrchestratorPool = class {
    * model id, so this is read again after a write rather than carried over.
    */
   plannerProviderInEffect() {
-    return new WebConfig({
-      enabledRunners: this.enabledRunnerOverride(),
-      providerModelLists: this.cachedProviderLists
-    }).aiProvider;
+    return this.plannerConfig().aiProvider;
   }
   updateSettings(changes) {
-    const current = {
-      provider: this.plannerProviderInEffect(),
-      model: process.env.ORCHESTRATOR_MODEL ?? "",
-      effort: process.env.ORDEWELL_PLANNER_EFFORT ?? ""
-    };
+    const current = this.plannerConfig().planner;
     const rawEnv = changes.env && typeof changes.env === "object" && !Array.isArray(changes.env) ? changes.env : void 0;
     const admission = rawEnv ? core.admitSettingsEnv(rawEnv) : void 0;
     const envChanges = admission ? admission.accepted : void 0;
-    const plannerChange = {
+    const plannerChange = changes.inherited === true ? {} : {
       provider: envChanges?.AI_PROVIDER,
       model: envChanges?.ORCHESTRATOR_MODEL ?? stringField(changes.orchestratorModel),
       effort: envChanges?.ORDEWELL_PLANNER_EFFORT ?? stringField(changes.plannerThinkingEffort)
@@ -592,11 +647,13 @@ var OrchestratorPool = class {
       if (touched) {
         this.modelResolver.invalidate();
         this.modelResolver.refreshRunnerModels();
+        this.dropUnkeyedProviderLists();
       }
     }
     if (selection) {
-      process.env.ORCHESTRATOR_MODEL = selection.next.model;
+      if (plannerChange.provider !== void 0 || plannerChange.model !== void 0) process.env.ORCHESTRATOR_MODEL = selection.next.model;
       process.env.ORDEWELL_PLANNER_EFFORT = selection.next.effort;
+      if (plannerChange.model !== void 0) this.pickedModel = { model: selection.next.model, provider: this.plannerProviderInEffect() };
     }
     if (changes.modelAllowlist && typeof changes.modelAllowlist === "object") {
       const allowlist = changes.modelAllowlist;
@@ -619,6 +676,20 @@ var OrchestratorPool = class {
     if (selection?.recall) settings.switchRecall = selection.recall;
     return settings;
   }
+  /**
+   * A vendor whose credential is gone keeps no list to route a model to it,
+   * or the next turn would be sent to a planner the settings response no
+   * longer names. Pruned rather than cleared: the vendors that still hold a
+   * key keep routing their models until the catalog is discovered again, so
+   * adding a second key does not move the planner off the first.
+   */
+  dropUnkeyedProviderLists() {
+    if (!this.cachedProviderLists) return;
+    const keyed = new Set(core.configuredProviders(new WebConfig()));
+    this.cachedProviderLists = Object.fromEntries(
+      Object.entries(this.cachedProviderLists).filter(([provider]) => keyed.has(provider))
+    );
+  }
   setOrchestratorModel(model) {
     process.env.ORCHESTRATOR_MODEL = model;
     return model;
@@ -651,14 +722,14 @@ var OrchestratorPool = class {
       models: allModels,
       modelsByRunner,
       modesByRunner: core.runnerModesFrom(this.registry, runnerIds),
-      orchestratorModel: process.env.ORCHESTRATOR_MODEL || "",
+      orchestratorModel: this.plannerConfig().orchestratorModel,
       providers,
       orchestratorModels,
       providerErrors
     };
   }
   getRunnerState() {
-    const config = new WebConfig({ enabledRunners: this.enabledRunnerOverride() });
+    const config = this.plannerConfig();
     return { enabledRunners: config.enabledRunners, orchestratorModel: config.orchestratorModel };
   }
   /**
@@ -667,9 +738,11 @@ var OrchestratorPool = class {
    * runner can't be spawned.
    */
   async getInstalledRunners() {
+    await this.codexSandbox.refresh();
+    this.runnerInstallation.refresh?.();
+    await this.detectInstalledPlanner();
     const config = new WebConfig({ enabledRunners: this.enabledRunnerOverride() });
     const enabled = new Set(config.enabledRunners);
-    await this.codexSandbox.refresh();
     const runners = this.registry.list();
     const installedIds = new Set(
       await this.runnerInstallation.filterInstalled(runners.map((p) => p.manifest.name))
@@ -681,11 +754,20 @@ var OrchestratorPool = class {
     }));
   }
   async generatePlan(sessionId, goal, runners, workspace, modelOverride, options) {
+    const session = this.openPlanningSession(sessionId, workspace, modelOverride, options);
+    return core.migratePlanState(await this.firstTurn(sessionId, session, () => session.generatePlan(goal, runners)));
+  }
+  /**
+   * Build the session a new planning conversation runs in and register it in
+   * place of any live one, for {@link firstTurn} to run its first turn on.
+   */
+  openPlanningSession(sessionId, workspace, modelOverride, options) {
     const session = this.createSessionFor(sessionId, workspace, modelOverride, options);
+    if (core.installedPlannerAnswered()) session.assertPlannerReady();
     this.destroy(sessionId);
     this.sessions.set(sessionId, session);
     this.warmCodexSandbox();
-    return core.migratePlanState(await session.generatePlan(goal, runners));
+    return session;
   }
   /**
    * Conversational planning (ADR-0002): start the planner dialogue for a
@@ -694,13 +776,16 @@ var OrchestratorPool = class {
    * assistant message lives in conversationHistory).
    */
   async startPlanning(sessionId, goal, runners, workspace, modelOverride, options) {
-    const session = this.createSessionFor(sessionId, workspace, modelOverride, options);
-    this.destroy(sessionId);
-    this.sessions.set(sessionId, session);
-    this.warmCodexSandbox();
-    return session.startPlanning(goal, runners);
+    const session = this.openPlanningSession(sessionId, workspace, modelOverride, options);
+    return this.firstTurn(sessionId, session, () => session.startPlanning(goal, runners));
   }
-  /** Continue the planner dialogue with the user's reply; refused while a planner turn is in flight. */
+  /**
+   * Continue the planner dialogue with the user's reply: queued behind the
+   * first turn, even while it waits for the installed-planner probe, and
+   * refused only while a turn of another kind holds the conversation. The
+   * session's own planner gate waits for the probe and judges the planner, as
+   * it does for every turn.
+   */
   async continuePlanning(sessionId, message) {
     return this.session(sessionId).continueConversation(message);
   }
@@ -788,6 +873,7 @@ function classify(err) {
   if (err instanceof core.AlreadyExecutingError) return { status: 409, code: "already_executing" };
   if (err instanceof core.WorkspaceNotAProjectError) return { status: 400, code: "workspace_not_a_project" };
   if (err instanceof core.WorkspaceNotFoundError) return { status: 400, code: "workspace_not_found" };
+  if (err instanceof core.PlannerNotReadyError) return { status: 409, code: "planner_not_ready" };
   if (err instanceof core.PlannerTurnStoppedError) return { status: 409, code: "planner_turn_stopped" };
   if (err instanceof core.PlannerTurnDiscardedError) return { status: 409, code: "planner_turn_discarded" };
   if (err instanceof core.ConversationBusyError) return { status: 409, code: "conversation_busy" };
@@ -807,7 +893,8 @@ function failure(c, err, label, { fallback = 500, message = "Internal error" } =
   const body = {
     error: err instanceof Error && err.message || message,
     ...classified ? { code: classified.code } : {},
-    ...err instanceof core.WorkspaceNotAProjectError ? { workspace: err.workspace } : {}
+    ...err instanceof core.WorkspaceNotAProjectError ? { workspace: err.workspace } : {},
+    ...err instanceof core.PlannerNotReadyError ? { plannerNotReady: err.reason } : {}
   };
   return c.json(body, status);
 }
@@ -860,7 +947,7 @@ function sessionsRoute(pool2) {
   });
   return router;
 }
-var NO_CHECKPOINT = "The task is not waiting at a checkpoint \u2014 it was answered already, withdrawn, or has no runner left to hear it.";
+var NO_CHECKPOINT = "The task is not waiting at a checkpoint: it was answered already, withdrawn, or has no runner left to hear it.";
 async function runUserCommand(session, command) {
   const outcome = await session.execute(command, { kind: "user" });
   if (!outcome.ok) throw new core.TaskControlError(outcome.message);
@@ -874,7 +961,7 @@ function plansRoute(pool2) {
       if (!goal) return c.json({ error: "goal is required" }, 400);
       const ws = workspace || c.req.query("workspace") || process.cwd();
       const queryRunners = c.req.query("runners");
-      const runnerList = Array.isArray(runners) ? runners : runners ? [runners] : queryRunners ? queryRunners.split(",").map((s) => s.trim()).filter(Boolean) : pool2.getRunnerState().enabledRunners;
+      const runnerList = Array.isArray(runners) ? runners : runners ? [runners] : queryRunners ? queryRunners.split(",").map((s) => s.trim()).filter(Boolean) : void 0;
       const plan = await pool2.generatePlan(c.req.param("sessionId"), goal, runnerList, ws, model, { allowInit });
       const { models, modelsByRunner } = await pool2.getProviderModels();
       const notes = (pool2.session(c.req.param("sessionId")).planState?.conversationHistory ?? []).filter((e) => e.kind === "system").map((e) => e.content);
@@ -897,7 +984,9 @@ function plansRoute(pool2) {
   router.post("/:sessionId/stop", async (c) => {
     try {
       if (pool2.hasSession(c.req.param("sessionId"))) {
-        await pool2.session(c.req.param("sessionId")).execute({ command: "stop_run" }, { kind: "user" });
+        const session = pool2.session(c.req.param("sessionId"));
+        const outcome = await session.execute({ command: "stop_run" }, { kind: "user" });
+        if (!outcome.ok && (session.isExecuting || session.startsPending)) throw new core.TaskControlError(outcome.message);
       }
       return c.json({ status: "stopped" });
     } catch (err) {
@@ -1181,7 +1270,7 @@ function plansRoute(pool2) {
       const { goal, runners, workspace, model, allowInit } = await c.req.json();
       if (!goal) return c.json({ error: "goal is required" }, 400);
       const ws = workspace || c.req.query("workspace") || process.cwd();
-      const runnerList = Array.isArray(runners) ? runners : runners ? [runners] : pool2.getRunnerState().enabledRunners;
+      const runnerList = Array.isArray(runners) ? runners : runners ? [runners] : void 0;
       const plan = await pool2.startPlanning(c.req.param("sessionId"), goal, runnerList, ws, model, { allowInit });
       return c.json({ plan: core.surfacePlan(plan) });
     } catch (err) {
@@ -1251,14 +1340,15 @@ function plansRoute(pool2) {
 function runnersRoute(pool2) {
   const router = new hono.Hono();
   router.get("/", async (c) => {
-    const state = pool2.getRunnerState();
     const runners = await pool2.getInstalledRunners();
+    const state = pool2.getRunnerState();
     return c.json({
       runners,
       orchestratorModel: state.orchestratorModel
     });
   });
   router.put("/:id", async (c) => {
+    await core.installedPlannerDetected();
     const id = c.req.param("id");
     const body = await c.req.json();
     pool2.setRunnerEnabled(id, body.enabled);
@@ -1314,7 +1404,7 @@ function approvalsRoute(pool2) {
       );
       if (!outcome.ok) return refuse(c, 400, outcome.message, "refused");
     } else if (!pool2.resolveApproval(sessionId, approvalId, answer)) {
-      return refuse(c, 409, "Approval is no longer outstanding \u2014 it timed out or was already answered.", "approval_not_outstanding");
+      return refuse(c, 409, "Approval is no longer outstanding: it timed out or was already answered.", "approval_not_outstanding");
     }
     return c.json({ ok: true, granted: core.isGranted(decided), decision: decided.decision });
   });
@@ -1322,11 +1412,13 @@ function approvalsRoute(pool2) {
 }
 function settingsRoute(pool2) {
   const router = new hono.Hono();
-  router.get("/", (c) => {
+  router.get("/", async (c) => {
+    await core.installedPlannerDetected();
     const settings = pool2.getSettings();
     return c.json(settings);
   });
   router.patch("/", async (c) => {
+    await core.installedPlannerDetected();
     const body = await c.req.json();
     if (!body || typeof body !== "object" || Array.isArray(body) || Object.keys(body).length === 0) {
       return refuse(c, 400, "At least one setting field is required");
@@ -1378,7 +1470,15 @@ function createWsHandler(pool2) {
     });
     ws.send(JSON.stringify({ type: "connected", sessionId }));
     const view = pool2.runSnapshot(sessionId);
-    if (view) ws.send(JSON.stringify({ type: "run_snapshot", sessionId, view }));
+    if (view) {
+      ws.send(JSON.stringify({
+        type: "run_snapshot",
+        sessionId,
+        view,
+        approvals: pool2.announcedApprovals(sessionId),
+        ...pool2.streamPosition(sessionId)
+      }));
+    }
     pool2.subscribe(sessionId, ws);
   });
   return (request, socket, head) => {
@@ -1552,6 +1652,7 @@ if (portIdx !== -1 && args[portIdx + 1]) {
 var watchParentIdx = args.indexOf("--watch-parent");
 var watchParentPid = watchParentIdx !== -1 ? parseInt(args[watchParentIdx + 1], 10) : void 0;
 var pool = new OrchestratorPool({ runner: new core.StructuredRunner() });
+void pool.detectInstalledPlanner();
 var server = http.createServer();
 var ownsToken = false;
 server.listen(port, "127.0.0.1", () => {