@atolis-hq/wake 0.1.0

package/dist/src/main.js

@@ -0,0 +1,523 @@
+#!/usr/bin/env node
+import { spawn } from 'node:child_process';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createDockerCli } from './adapters/docker/docker-cli.js';
+import { createFileBackedFakeTicketingSystem } from './adapters/fake/fake-ticketing-system.js';
+import { createFakeWorkspaceManager } from './adapters/fake/fake-workspace-manager.js';
+import { createGitWorkspaceManager } from './adapters/git/git-workspace-manager.js';
+import { createRunnerCliAdapter } from './adapters/runner/runner-cli-adapter.js';
+import { createRegistryRunner, runnerKindForOverride, } from './adapters/runner/runner-registry.js';
+import { createResourceIndex } from './adapters/fs/resource-index.js';
+import { createStateStore } from './adapters/fs/state-store.js';
+import { readSelfUpdateLedger, writeSelfUpdateLedger, } from './adapters/fs/self-update-ledger.js';
+import { resolveGitHubToken } from './adapters/github/github-auth.js';
+import { createGitHubArtifactVerifier } from './adapters/github/github-artifact-verifier.js';
+import { createGitHubClient } from './adapters/github/github-client.js';
+import { createGitHubIssuesWorkSource } from './adapters/github/github-issues-work-source.js';
+import { createGitHubPullRequestActivitySource } from './adapters/github/github-pull-request-activity-source.js';
+import { runCorrelateCommand } from './cli/correlate-command.js';
+import { runInitCommand } from './cli/init-command.js';
+import { runSandboxCommand } from './cli/sandbox-command.js';
+import { runStartupPreflight } from './cli/startup-preflight.js';
+import { runUiCommand } from './cli/ui-command.js';
+import { loadWakeConfig } from './config/load-config.js';
+import { createControlPlane } from './core/control-plane.js';
+import { createOutboundSinkRouter, createWorkSourceFanIn } from './core/sink-router.js';
+import { createTickRunner } from './core/tick-runner.js';
+import { systemClock } from './lib/clock.js';
+import { configuredTicketSource } from './domain/sources.js';
+import { wakeVersion } from './version.js';
+function commandArgsBeforeTerminator(args) {
+    const terminatorIndex = args.indexOf('--');
+    if (terminatorIndex === -1) {
+        return args;
+    }
+    return args.slice(0, terminatorIndex);
+}
+export function readFlagBeforeCommandTerminator(name, args) {
+    const scopedArgs = commandArgsBeforeTerminator(args);
+    const index = scopedArgs.indexOf(name);
+    if (index === -1) {
+        return undefined;
+    }
+    return scopedArgs[index + 1];
+}
+function hasFlag(name, args) {
+    return commandArgsBeforeTerminator(args).includes(name);
+}
+function resolvePackageRoot() {
+    return resolve(dirname(fileURLToPath(import.meta.url)), '..', '..');
+}
+function routesOnlyToFake(config) {
+    return Object.values(config.tiers).every((candidates) => {
+        const first = candidates[0];
+        return first !== undefined && config.runners[first]?.kind === 'fake';
+    });
+}
+export function formatTickFailureDetails(runRecord) {
+    if (runRecord === null) {
+        return null;
+    }
+    const summary = runRecord.summary?.trim();
+    const exitCode = runRecord.metadata !== undefined && typeof runRecord.metadata.exitCode === 'number'
+        ? runRecord.metadata.exitCode
+        : undefined;
+    const stderr = runRecord.metadata !== undefined && typeof runRecord.metadata.stderr === 'string'
+        ? runRecord.metadata.stderr.trim()
+        : '';
+    if (summary === undefined && exitCode === undefined && stderr.length === 0) {
+        return null;
+    }
+    const lines = ['Tick failure details:', `runId: ${runRecord.runId}`];
+    if (exitCode !== undefined) {
+        lines.push(`exitCode: ${exitCode}`);
+    }
+    if (summary !== undefined) {
+        lines.push('', 'Summary:', summary);
+    }
+    if (stderr.length > 0) {
+        lines.push('', 'stderr:', stderr);
+    }
+    return lines.join('\n');
+}
+async function runCommand(command, args, env = process.env) {
+    await new Promise((resolveRun, reject) => {
+        const child = spawn(command, args, {
+            cwd: process.cwd(),
+            env,
+            stdio: 'inherit',
+        });
+        child.on('error', reject);
+        child.on('close', (exitCode) => {
+            if (exitCode === 0) {
+                resolveRun();
+                return;
+            }
+            reject(new Error(`${command} ${args.join(' ')} failed with exit code ${exitCode ?? 1}`));
+        });
+    });
+}
+function parseGithubRepoSlug(remoteUrl) {
+    const match = /github\.com[:/]([^/]+\/[^/]+?)(?:\.git)?$/.exec(remoteUrl.trim());
+    if (match === null) {
+        throw new Error(`Could not parse a GitHub owner/repo from origin remote: ${remoteUrl}`);
+    }
+    return match[1];
+}
+async function runCommandCapture(command, args) {
+    return await new Promise((resolveRun, reject) => {
+        const child = spawn(command, args, {
+            cwd: process.cwd(),
+            env: process.env,
+            stdio: ['ignore', 'pipe', 'inherit'],
+        });
+        let stdout = '';
+        child.stdout.on('data', (chunk) => {
+            stdout += chunk.toString();
+        });
+        child.on('error', reject);
+        child.on('close', (exitCode) => {
+            if (exitCode === 0) {
+                resolveRun(stdout);
+                return;
+            }
+            reject(new Error(`${command} ${args.join(' ')} failed with exit code ${exitCode ?? 1}`));
+        });
+    });
+}
+async function inspectDockerImage(image) {
+    return await new Promise((resolveInspect, reject) => {
+        const child = spawn('docker', ['image', 'inspect', image], {
+            cwd: process.cwd(),
+            env: process.env,
+            stdio: 'ignore',
+        });
+        child.on('error', reject);
+        child.on('close', (exitCode) => {
+            resolveInspect(exitCode === 0);
+        });
+    });
+}
+async function inspectDockerContainer(containerName) {
+    return await new Promise((resolveInspect, reject) => {
+        const child = spawn('docker', ['container', 'inspect', '-f', '{{.State.Running}}', containerName], {
+            cwd: process.cwd(),
+            env: process.env,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        let stdout = '';
+        child.stdout.on('data', (chunk) => {
+            stdout += chunk.toString();
+        });
+        child.on('error', reject);
+        child.on('close', (exitCode) => {
+            if (exitCode !== 0) {
+                resolveInspect(null);
+                return;
+            }
+            resolveInspect(stdout.trim() === 'true' ? 'running' : 'stopped');
+        });
+    });
+}
+export async function buildRuntime(args) {
+    const wakeRoot = resolve(readFlagBeforeCommandTerminator('--wake-root', args) ?? resolve(process.cwd(), '.wake'));
+    const stateStore = createStateStore({ wakeRoot });
+    await stateStore.ensureWakeRoot();
+    const config = await loadWakeConfig({
+        wakeRoot,
+        configFile: stateStore.paths.configFile,
+    });
+    await stateStore.writeConfig(config);
+    const resourceIndex = createResourceIndex({ paths: stateStore.paths });
+    const prTrackingEnabled = config.sources.github.enabled && config.sources.github.pullRequests.enabled;
+    // Resolved once and shared: resolveGitHubToken shells out to `gh auth
+    // token`, so building a separate client per consumer would triple that
+    // subprocess spawn on every startup for no benefit — all three consumers
+    // talk to the same GitHub account under the same config.
+    const githubClient = config.sources.github.enabled
+        ? createGitHubClient(await resolveGitHubToken())
+        : undefined;
+    const artifactVerifier = prTrackingEnabled && githubClient !== undefined
+        ? createGitHubArtifactVerifier({ client: githubClient })
+        : undefined;
+    const ticketingSystem = githubClient !== undefined
+        ? createGitHubIssuesWorkSource({
+            client: githubClient,
+            stateStore,
+            config,
+            resourceIndex,
+            now: () => systemClock.now(),
+        })
+        : await createFileBackedFakeTicketingSystem({
+            fixturePath: stateStore.paths.issueFixtureFile,
+            now: () => systemClock.now(),
+        });
+    const sourceName = configuredTicketSource(config);
+    const sinkName = sourceName;
+    const pullRequestActivitySource = prTrackingEnabled && githubClient !== undefined
+        ? createGitHubPullRequestActivitySource({
+            client: githubClient,
+            stateStore,
+            config,
+            resourceIndex,
+            now: () => systemClock.now(),
+        })
+        : null;
+    const workSource = createWorkSourceFanIn([
+        {
+            source: sourceName,
+            pollEvents: ticketingSystem.pollEvents,
+        },
+        ...(pullRequestActivitySource === null
+            ? []
+            : [{ source: 'github-pr', pollEvents: pullRequestActivitySource.pollEvents }]),
+    ]);
+    const outboundSink = createOutboundSinkRouter({
+        sinks: [
+            {
+                sink: sinkName,
+                deliverIntent: ticketingSystem.deliverIntent,
+            },
+            ...(pullRequestActivitySource === null
+                ? []
+                : [{ sink: 'github-pr', deliverIntent: pullRequestActivitySource.deliverIntent }]),
+        ],
+        config,
+    });
+    const runnerOverride = readFlagBeforeCommandTerminator('--runner', args);
+    if (runnerOverride !== undefined &&
+        runnerOverride !== 'fake' &&
+        config.runners[runnerOverride] === undefined) {
+        throw new Error(`Unsupported runner override: ${runnerOverride}`);
+    }
+    const runner = createRegistryRunner({
+        config,
+        cwd: process.cwd(),
+        ...(runnerOverride === undefined ? {} : { override: runnerOverride }),
+    });
+    const workspaceManager = (runnerOverride !== undefined
+        ? runnerKindForOverride(config, runnerOverride) === 'fake'
+        : routesOnlyToFake(config))
+        ? createFakeWorkspaceManager(stateStore.paths.workspaceRoot)
+        : createGitWorkspaceManager({ wakeRoot });
+    const tickRunner = createTickRunner({
+        clock: systemClock,
+        config,
+        stateStore,
+        workSource,
+        outboundSink,
+        runner,
+        workspaceManager,
+        resourceIndex,
+        ...(artifactVerifier === undefined ? {} : { artifactVerifier }),
+    });
+    return {
+        config,
+        runnerAdapter: null,
+        runner,
+        stateStore,
+        tickRunner,
+        workspaceManager,
+    };
+}
+async function runTick(args) {
+    const runtime = await buildRuntime(args);
+    const outcome = await runtime.tickRunner.runTick();
+    console.log(JSON.stringify(outcome, null, 2));
+    if (outcome.status !== 'processed' || outcome.sentinel !== 'FAILED' || outcome.runId === undefined) {
+        return;
+    }
+    const runRecord = await runtime.stateStore.readRunRecord(outcome.runId);
+    const details = formatTickFailureDetails(runRecord);
+    if (details !== null) {
+        console.error(details);
+    }
+}
+async function runStart(args) {
+    const runtime = await buildRuntime(args);
+    const runnerOverride = readFlagBeforeCommandTerminator('--runner', args);
+    await runStartupPreflight(runtime.config, {
+        ...(runnerOverride === undefined ? {} : { runnerOverride }),
+        workspaceManager: runtime.workspaceManager,
+    });
+    const controlPlane = createControlPlane({
+        tickRunner: runtime.tickRunner,
+        intervalMs: runtime.config.scheduler.intervalMs,
+        maxIntervalMs: runtime.config.scheduler.maxIntervalMs,
+        isPaused: () => runtime.stateStore.isPaused(),
+        logger: {
+            info(message) {
+                console.log(message);
+            },
+            error(message) {
+                console.error(message);
+            },
+        },
+        sleep(ms) {
+            return new Promise((resolveSleep) => {
+                setTimeout(resolveSleep, ms);
+            });
+        },
+    });
+    const stop = () => controlPlane.stop();
+    process.on('SIGINT', stop);
+    process.on('SIGTERM', stop);
+    await controlPlane.start();
+}
+function resolveSmokEntry(config, kind) {
+    for (const entry of Object.values(config.runners)) {
+        if (entry.kind === 'fake') {
+            continue;
+        }
+        if (kind === undefined || entry.kind === kind) {
+            return entry;
+        }
+    }
+    return null;
+}
+async function runUi(args) {
+    const wakeRoot = resolve(readFlagBeforeCommandTerminator('--wake-root', args) ?? resolve(process.cwd(), '.wake'));
+    const stateStore = createStateStore({ wakeRoot });
+    await stateStore.ensureWakeRoot();
+    const config = await loadWakeConfig({
+        wakeRoot,
+        configFile: stateStore.paths.configFile,
+    });
+    const server = await runUiCommand({
+        args,
+        stateStore,
+        resourceIndex: createResourceIndex({ paths: stateStore.paths }),
+        config,
+        readFlag: readFlagBeforeCommandTerminator,
+    });
+    const stop = () => {
+        void server.close().then(() => process.exit(0));
+    };
+    process.on('SIGINT', stop);
+    process.on('SIGTERM', stop);
+    await new Promise(() => { });
+}
+async function runCorrelate(args) {
+    const wakeRoot = resolve(readFlagBeforeCommandTerminator('--wake-root', args) ?? resolve(process.cwd(), '.wake'));
+    const stateStore = createStateStore({ wakeRoot });
+    await stateStore.ensureWakeRoot();
+    await runCorrelateCommand({
+        args,
+        stateStore,
+        resourceIndex: createResourceIndex({ paths: stateStore.paths }),
+        clock: systemClock,
+        readFlag: readFlagBeforeCommandTerminator,
+    });
+}
+async function runSmoke(args) {
+    const runtime = await buildRuntime(args);
+    const explicitKind = args[0] === 'claude' || args[0] === 'codex' || args[0] === 'cursor' ? args[0] : undefined;
+    const smokeArgs = explicitKind === undefined ? args : args.slice(1);
+    const entry = resolveSmokEntry(runtime.config, explicitKind);
+    if (entry === null) {
+        throw new Error('Smoke tests require a real runner entry (`claude`, `codex`, or `cursor`) in config.runners.');
+    }
+    const runnerAdapter = createRunnerCliAdapter({
+        entry,
+        cwd: process.cwd(),
+    });
+    const result = await runnerAdapter.smoke(smokeArgs);
+    console.log(JSON.stringify(result, null, 2));
+}
+export async function dispatchMainCommand(input) {
+    const command = input.args[0] ?? 'tick';
+    if (command === '--version' || command === '-v' || command === 'version') {
+        console.log(wakeVersion);
+        return;
+    }
+    if (command === 'tick') {
+        await input.runTick(input.args.slice(1));
+        return;
+    }
+    if (command === 'start') {
+        await input.runStart(input.args.slice(1));
+        return;
+    }
+    if (command === 'init') {
+        await input.runInit(input.args.slice(1));
+        return;
+    }
+    if (command === 'sandbox') {
+        await input.runSandbox(input.args.slice(1));
+        return;
+    }
+    if (command === 'stop') {
+        await input.runSandbox(['stop', ...input.args.slice(1)]);
+        return;
+    }
+    if (command === 'smoke') {
+        await input.runSmoke(input.args.slice(1));
+        return;
+    }
+    if (command === 'ui') {
+        await input.runUi(input.args.slice(1));
+        return;
+    }
+    if (command === 'correlate') {
+        await input.runCorrelate(input.args.slice(1));
+        return;
+    }
+    throw new Error(`Unknown command: ${input.args.join(' ')}`);
+}
+async function main() {
+    const args = process.argv.slice(2);
+    await dispatchMainCommand({
+        args,
+        runInit: async (commandArgs) => {
+            await runInitCommand({
+                cwd: process.cwd(),
+                args: commandArgs,
+                repoRoot: resolvePackageRoot(),
+            });
+        },
+        runSandbox: async (commandArgs) => {
+            const wakeRoot = resolve(readFlagBeforeCommandTerminator('--wake-root', commandArgs) ?? process.cwd());
+            const stateStore = createStateStore({ wakeRoot });
+            await stateStore.ensureWakeRoot();
+            const config = await loadWakeConfig({
+                wakeRoot,
+                configFile: stateStore.paths.configFile,
+            });
+            const docker = createDockerCli({
+                // BuildKit is required for the Dockerfile's cache-mount syntax
+                // (`RUN --mount=type=cache`), which keeps `npm`/`apt` package
+                // caches warm across builds even when a layer above them changes.
+                run: (dockerArgs) => runCommand('docker', dockerArgs, { ...process.env, DOCKER_BUILDKIT: '1' }),
+                inspectImage: inspectDockerImage,
+                inspectContainer: inspectDockerContainer,
+            });
+            const repoRoot = config.dev?.repoRoot;
+            const selfUpdate = commandArgs[0] === 'self-update' && repoRoot !== undefined && repoRoot.length > 0
+                ? {
+                    git: {
+                        latestTag: async () => {
+                            await runCommand('git', ['-C', repoRoot, 'fetch', '--tags']);
+                            const output = await runCommandCapture('git', [
+                                '-C',
+                                repoRoot,
+                                'tag',
+                                '--list',
+                                'v*',
+                                '--sort=-v:refname',
+                            ]);
+                            const [latest] = output.split('\n').filter((line) => line.trim().length > 0);
+                            if (latest === undefined) {
+                                throw new Error('No version tags found in repo');
+                            }
+                            return latest.trim();
+                        },
+                        isWorkingTreeClean: async () => {
+                            const output = await runCommandCapture('git', [
+                                '-C',
+                                repoRoot,
+                                'status',
+                                '--porcelain',
+                            ]);
+                            return output.trim().length === 0;
+                        },
+                        checkoutTag: async (tag) => {
+                            await runCommand('git', ['-C', repoRoot, 'checkout', tag]);
+                        },
+                    },
+                    issueReporter: {
+                        createIssue: async (issue) => {
+                            const remoteUrl = await runCommandCapture('git', [
+                                '-C',
+                                repoRoot,
+                                'remote',
+                                'get-url',
+                                'origin',
+                            ]);
+                            const repoSlug = parseGithubRepoSlug(remoteUrl);
+                            await runCommand('gh', [
+                                'issue',
+                                'create',
+                                '--repo',
+                                repoSlug,
+                                '--title',
+                                issue.title,
+                                '--body',
+                                issue.body,
+                            ]);
+                        },
+                    },
+                    readLedger: () => readSelfUpdateLedger(resolve(wakeRoot, 'self-update-ledger.json')),
+                    writeLedger: (ledger) => writeSelfUpdateLedger(resolve(wakeRoot, 'self-update-ledger.json'), ledger),
+                }
+                : undefined;
+            await runSandboxCommand({
+                args: commandArgs,
+                config,
+                wakeRoot,
+                containerHomeRoot: stateStore.paths.containerHomeRoot,
+                docker,
+                stateStore,
+                sleep: (ms) => new Promise((resolveSleep) => setTimeout(resolveSleep, ms)),
+                logger: {
+                    info(message) {
+                        console.log(message);
+                    },
+                    error(message) {
+                        console.error(message);
+                    },
+                },
+                selfUpdate,
+            });
+        },
+        runTick,
+        runStart,
+        runSmoke,
+        runUi,
+        runCorrelate,
+    });
+}
+main().catch((error) => {
+    console.error(error);
+    process.exitCode = 1;
+});

package/dist/src/version.js

@@ -0,0 +1 @@
+export const wakeVersion = "v0.0.108";

package/docker/Dockerfile

@@ -0,0 +1,54 @@
+# syntax=docker/dockerfile:1
+FROM node:20-bookworm-slim
+
+RUN --mount=type=cache,target=/var/cache/apt,sharing=locked \
+    --mount=type=cache,target=/var/lib/apt/lists,sharing=locked \
+  apt-get update \
+  && apt-get install -y --no-install-recommends git openssh-client ca-certificates curl gnupg \
+  && mkdir -p /etc/apt/keyrings \
+  && curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg \
+    | gpg --dearmor -o /etc/apt/keyrings/githubcli-archive-keyring.gpg \
+  && chmod go+r /etc/apt/keyrings/githubcli-archive-keyring.gpg \
+  && echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" \
+    > /etc/apt/sources.list.d/github-cli.list \
+  && curl -fsSL https://ngrok-agent.s3.amazonaws.com/ngrok.asc \
+    | gpg --dearmor -o /etc/apt/keyrings/ngrok-archive-keyring.gpg \
+  && chmod go+r /etc/apt/keyrings/ngrok-archive-keyring.gpg \
+  && echo "deb [signed-by=/etc/apt/keyrings/ngrok-archive-keyring.gpg] https://ngrok-agent.s3.amazonaws.com buster main" \
+    > /etc/apt/sources.list.d/ngrok.list \
+  && apt-get update \
+  && apt-get install -y --no-install-recommends gh ngrok
+
+RUN --mount=type=cache,target=/root/.npm \
+  npm install -g @anthropic-ai/claude-code @openai/codex
+
+RUN useradd --create-home --shell /bin/bash wake \
+  && mkdir -p /home/wake/.codex-runtime \
+  && mkdir -p /home/wake/.cursor \
+  && chown -R wake:wake /home/wake/.codex-runtime \
+  && chown -R wake:wake /home/wake/.cursor
+
+ENV CODEX_HOME=/home/wake/.codex-runtime
+ENV PATH=/home/wake/.local/bin:$PATH
+
+RUN curl https://cursor.com/install -fsS | HOME=/home/wake bash \
+  && printf '#!/bin/bash\n[ "$1" = "agent" ] && shift\nexec ~/.local/bin/agent "$@"\n' \
+     > /home/wake/.local/bin/cursor \
+  && chmod +x /home/wake/.local/bin/cursor \
+  && chown -R wake:wake /home/wake/.local
+
+WORKDIR /app
+COPY package*.json ./
+RUN --mount=type=cache,target=/root/.npm \
+  if [ -f package-lock.json ]; then npm ci; else npm install; fi
+
+COPY . .
+ARG WAKE_BUILD_TAG
+RUN WAKE_BUILD_TAG="$WAKE_BUILD_TAG" npm run build && chmod +x docker/entrypoint.sh
+
+USER wake
+WORKDIR /home/wake
+
+EXPOSE 4317
+
+ENTRYPOINT ["/app/docker/entrypoint.sh"]

package/docker/entrypoint.sh

@@ -0,0 +1,75 @@
+#!/usr/bin/env bash
+set -uo pipefail
+
+mkdir -p /wake/logs
+
+write_ngrok_public_url() {
+  local output_file="/wake/control-plane-ui-url"
+
+  rm -f "${output_file}"
+  for _ in $(seq 1 30); do
+    local public_url
+    public_url="$(
+      node -e '
+const http = require("node:http");
+const req = http.get("http://127.0.0.1:4040/api/tunnels", (res) => {
+  let body = "";
+  res.setEncoding("utf8");
+  res.on("data", (chunk) => { body += chunk; });
+  res.on("end", () => {
+    try {
+      const tunnels = JSON.parse(body).tunnels ?? [];
+      const tunnel = tunnels.find((entry) => typeof entry.public_url === "string" && entry.public_url.startsWith("https://"))
+        ?? tunnels.find((entry) => typeof entry.public_url === "string");
+      if (tunnel !== undefined) {
+        process.stdout.write(tunnel.public_url);
+      }
+    } catch {}
+  });
+});
+req.on("error", () => {});
+req.setTimeout(1000, () => req.destroy());
+' || true
+    )"
+
+    if [ -n "${public_url}" ]; then
+      printf '%s\n' "${public_url}" > "${output_file}"
+      echo "wake ui: ngrok tunnel available at ${public_url}"
+      return 0
+    fi
+
+    sleep 1
+  done
+
+  echo "wake ui: ngrok tunnel started but public URL was not discovered; see /wake/logs/ngrok.log"
+}
+
+if [ "${WAKE_UI_ENABLED:-false}" = "true" ]; then
+  echo "wake ui: starting on 0.0.0.0:${WAKE_UI_PORT:-4317}"
+  node /app/dist/src/main.js ui \
+    --wake-root /wake \
+    --host 0.0.0.0 \
+    --port "${WAKE_UI_PORT:-4317}" \
+    ${WAKE_UI_TOKEN:+--token "${WAKE_UI_TOKEN}"} \
+    >> /wake/logs/ui.log 2>&1 &
+
+  if [ "${WAKE_UI_TUNNEL_ENABLED:-false}" = "true" ]; then
+    if [ -n "${NGROK_AUTHTOKEN:-}" ]; then
+      ngrok config add-authtoken "${NGROK_AUTHTOKEN}" >> /wake/logs/ngrok.log 2>&1
+    fi
+
+    echo "wake ui: starting ngrok tunnel for 127.0.0.1:${WAKE_UI_PORT:-4317}"
+    ngrok http "127.0.0.1:${WAKE_UI_PORT:-4317}" --log=stdout >> /wake/logs/ngrok.log 2>&1 &
+    write_ngrok_public_url &
+  fi
+fi
+
+if [ "${WAKE_START_ENABLED:-false}" = "true" ]; then
+  echo "wake start: starting resident loop"
+  node /app/dist/src/main.js start \
+    --wake-root /wake \
+    >> /wake/logs/start.log 2>&1 &
+  echo "$!" > /wake/logs/start.pid
+fi
+
+exec sleep infinity