nebula-notebook 0.1.1 → 0.2.1

package/node-server/dist/routes/autocomplete.d.ts

@@ -0,0 +1,19 @@
+/**
+ * AI autocomplete API — inline code completions for notebook cells.
+ *
+ * Routes live under /api and are auth-protected like the rest of the API.
+ * Backed by the nebula-autocomplete engine, which drives a Claude Code / Codex
+ * CLI using the user's own subscription. The CLI can run in one of two places:
+ *
+ *   - on THIS server (default) — when the Nebula host itself has claude/codex
+ *     (a local install, or a login node where the CLIs are available);
+ *   - on the USER'S machine over the reverse SSH tunnel ("run on my machine") —
+ *     for remote Nebula where the user would rather use their own laptop's CLI +
+ *     subscription. See the `transport` field on the completion request.
+ *
+ * Engines are created lazily and cached per (backend, transport) so a warm pool
+ * is reused across turns; disposed on server shutdown.
+ */
+import { FastifyInstance } from 'fastify';
+export declare function disposeAutocompleteEngines(): void;
+export default function autocompleteRoutes(fastify: FastifyInstance): Promise<void>;

package/node-server/dist/routes/autocomplete.js

@@ -0,0 +1,294 @@
+"use strict";
+/**
+ * AI autocomplete API — inline code completions for notebook cells.
+ *
+ * Routes live under /api and are auth-protected like the rest of the API.
+ * Backed by the nebula-autocomplete engine, which drives a Claude Code / Codex
+ * CLI using the user's own subscription. The CLI can run in one of two places:
+ *
+ *   - on THIS server (default) — when the Nebula host itself has claude/codex
+ *     (a local install, or a login node where the CLIs are available);
+ *   - on the USER'S machine over the reverse SSH tunnel ("run on my machine") —
+ *     for remote Nebula where the user would rather use their own laptop's CLI +
+ *     subscription. See the `transport` field on the completion request.
+ *
+ * Engines are created lazily and cached per (backend, transport) so a warm pool
+ * is reused across turns; disposed on server shutdown.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.disposeAutocompleteEngines = disposeAutocompleteEngines;
+exports.default = autocompleteRoutes;
+const child_process_1 = require("child_process");
+const environment_1 = require("../environment");
+const nebula_autocomplete_1 = require("nebula-autocomplete");
+const server_1 = require("nebula-autocomplete/server");
+const engines = new Map();
+/**
+ * Async command runner. NEVER use spawnSync here: these probes run ssh calls
+ * that can take 10+ seconds, and spawnSync freezes Node's event loop — which
+ * stalls EVERYTHING the server does (terminal WS input, API responses), felt
+ * as "the whole app is unresponsive for ~10s after a refresh".
+ */
+function runCmd(cmd, args, timeoutMs) {
+    return new Promise((resolve) => {
+        let out = '';
+        let done = false;
+        const finish = (status) => { if (!done) {
+            done = true;
+            resolve({ status, stdout: out });
+        } };
+        let proc;
+        try {
+            proc = (0, child_process_1.spawn)(cmd, args, { stdio: ['ignore', 'pipe', 'ignore'] });
+        }
+        catch {
+            return finish(null);
+        }
+        const timer = setTimeout(() => { try {
+            proc.kill('SIGKILL');
+        }
+        catch { /* */ } finish(null); }, timeoutMs);
+        proc.stdout?.on('data', (d) => (out += d.toString()));
+        proc.on('error', () => { clearTimeout(timer); finish(null); });
+        proc.on('exit', (code) => { clearTimeout(timer); finish(code); });
+    });
+}
+async function binaryAvailable(name) {
+    return (await runCmd('which', [name], 3000)).status === 0;
+}
+/** Parse + validate a client-supplied transport (untrusted input). */
+function parseTransport(raw) {
+    if (!raw || typeof raw !== 'object')
+        return null;
+    const t = raw;
+    const port = Number(t.port);
+    const user = typeof t.user === 'string' ? t.user.trim() : '';
+    const bin = typeof t.bin === 'string' ? t.bin.trim() : '';
+    if (!Number.isInteger(port) || port <= 0 || port > 65535)
+        return null;
+    if (!user || !/^[A-Za-z0-9._-]+$/.test(user))
+        return null;
+    if (!bin.startsWith('/'))
+        return null; // must be an absolute path
+    const host = typeof t.host === 'string' && t.host.trim() ? t.host.trim() : 'localhost';
+    return { port, user, bin, host };
+}
+function toSsh(t) {
+    return { kind: 'ssh', host: t.host ?? 'localhost', port: t.port, user: t.user, remoteBin: t.bin };
+}
+function sanitizeTuning(name, raw) {
+    // Experimental tuning surface: any shell-safe model id is allowed (it's the
+    // user's own CLI/subscription; a bad id just fails the worker's warmup
+    // visibly). Pattern-gated so nothing hostile reaches the spawn argv.
+    let model = typeof raw.model === 'string' ? raw.model.trim().toLowerCase() : '';
+    if (name === 'claude') {
+        // Default sonnet (was haiku): BENCHMARKED (eval/bench.mjs, 54 samples/config,
+        // interleaved) — sonnet ttfb p50 1086ms vs haiku 987ms (+10%, fixed API
+        // overhead dominates short completions) while fixing haiku's context
+        // failures (100% vs 94% ctx-accuracy). Thinking: on haiku it engages
+        // every turn (probed: ~1-1.5k chars) = 3-8s of non-streaming dead air; on
+        // sonnet MAX_THINKING_TOKENS never engages at all for completion-sized
+        // prompts (probed: 0 thinking chars, 4/4), so it can't help there either.
+        model = /^[a-z0-9][a-z0-9._:-]{0,63}$/.test(model) ? model : 'sonnet';
+    }
+    else
+        model = ''; // codex: fixed model
+    const rawTokens = Number(raw.thinkingTokens);
+    const thinkingTokens = Number.isFinite(rawTokens)
+        ? Math.min(16_000, Math.max(0, Math.round(rawTokens)))
+        : raw.thinking === true ? 4096 : 0;
+    return { model, thinkingTokens };
+}
+function engineKey(name, t, tune) {
+    const base = t ? `${name}:ssh:${t.user}@${t.host ?? 'localhost'}:${t.port}:${t.bin}` : name;
+    return `${base}:${tune.model}:${tune.thinkingTokens}`;
+}
+function getEngine(name, t, tune) {
+    const key = engineKey(name, t, tune);
+    let engine = engines.get(key);
+    if (!engine) {
+        const backend = name === 'codex'
+            ? new nebula_autocomplete_1.CodexBackend({
+                codexHome: t ? undefined : process.env.NEBULA_AUTOCOMPLETE_CODEX_HOME,
+                transport: t ? toSsh(t) : { kind: 'local' },
+            })
+            : new nebula_autocomplete_1.ClaudeBackend({
+                transport: t ? toSsh(t) : { kind: 'local' },
+                ...(tune.model ? { model: tune.model } : {}),
+                maxThinkingTokens: tune.thinkingTokens,
+            });
+        // contextBudget 20000: field testing showed 20k chars of context leaves
+        // latency essentially unchanged (worker history is prefix-cached; only the
+        // new message is uncached) — an earlier small A/B suggesting otherwise was
+        // cache/variance artifact. 20k covers the whole notebook in most cases;
+        // per-request overrides (Advanced settings) are clamped inside the engine.
+        engine = new nebula_autocomplete_1.AutocompleteEngine({ backend, contextBudget: 20_000 });
+        engines.set(key, engine);
+    }
+    return engine;
+}
+function disposeAutocompleteEngines() {
+    for (const engine of engines.values())
+        engine.dispose();
+    engines.clear();
+}
+/**
+ * Discover the absolute path of a provider CLI on the user's machine over the
+ * reverse tunnel (PATH isn't set for a non-interactive ssh, so running the CLI
+ * needs an absolute path). Uses a login shell + a sentinel so rc-file noise
+ * doesn't corrupt the result. Best-effort; returns null on any failure.
+ */
+async function discoverRemoteBin(port, user, provider, host = 'localhost') {
+    if (!Number.isInteger(port) || !/^[A-Za-z0-9._-]+$/.test(user))
+        return null;
+    // `whence -p` FIRST: on the user's machine `claude`/`codex` is typically a zsh
+    // FUNCTION, so `command -v` returns the function name (not a path) and would
+    // short-circuit. `whence -p` (zsh) resolves the actual binary; `command -v` is
+    // the fallback for non-zsh login shells (where `whence` doesn't exist).
+    const remote = `$SHELL -lic 'printf "NB_BIN=%s\\n" "$(whence -p ${provider} 2>/dev/null || command -v ${provider} 2>/dev/null)"' 2>/dev/null`;
+    const res = await runCmd('ssh', ['-p', String(port), '-o', 'ProxyCommand=none', '-o', 'StrictHostKeyChecking=accept-new',
+        '-o', 'BatchMode=yes', '-o', 'ConnectTimeout=8', `${user}@${host}`, remote], 12000);
+    if (res.status !== 0 || !res.stdout)
+        return null;
+    const line = res.stdout.split('\n').find((l) => l.startsWith('NB_BIN='));
+    const bin = line ? line.slice('NB_BIN='.length).trim() : '';
+    return bin.startsWith('/') ? bin : null;
+}
+/**
+ * Actually RUN a provider CLI on THIS server with a trivial prompt to tell
+ * "installed" from "usable" (logged in). Bounded + best-effort. Returns a status
+ * the diagnostics UI can render.
+ */
+async function checkCliUsable(name) {
+    if (!(await binaryAvailable(name)))
+        return { installed: false, usable: false, detail: 'not installed on this server' };
+    return new Promise((resolve) => {
+        const cfg = `/tmp/nebula-diag-${name}-${process.pid}-${Math.round(process.hrtime()[1])}`;
+        const args = name === 'claude'
+            ? ['-p', 'reply with just: ok', '--model', 'haiku']
+            : ['exec', '--json', '--skip-git-repo-check', '--sandbox', 'read-only', '--color', 'never', '--ephemeral', '-m', 'gpt-5.6-luna', 'reply ok'];
+        const env = { ...process.env, CLAUDE_CODE_MAX_OUTPUT_TOKENS: '64', CLAUDE_CONFIG_DIR: cfg };
+        let out = '', err = '', done = false;
+        const finish = (r) => { if (!done) {
+            done = true;
+            resolve(r);
+        } };
+        let proc;
+        try {
+            proc = (0, child_process_1.spawn)(name, args, { env, stdio: ['ignore', 'pipe', 'pipe'] });
+        }
+        catch {
+            return finish({ installed: true, usable: false, detail: 'failed to launch' });
+        }
+        const timer = setTimeout(() => { try {
+            proc.kill('SIGKILL');
+        }
+        catch { /* */ } finish({ installed: true, usable: false, detail: 'timed out (no response in 25s)' }); }, 25000);
+        proc.stdout?.on('data', (d) => (out += d.toString()));
+        proc.stderr?.on('data', (d) => (err += d.toString()));
+        proc.on('error', () => { clearTimeout(timer); finish({ installed: true, usable: false, detail: 'failed to launch' }); });
+        proc.on('exit', (code) => {
+            clearTimeout(timer);
+            const blob = (out + '\n' + err).toLowerCase();
+            const authIssue = /log ?in|logged in|authenticat|unauthor|oauth|api key|credit balance|subscription|setup-token|not authenticated/.test(blob);
+            if (authIssue)
+                return finish({ installed: true, usable: false, detail: 'not logged in on this server' });
+            if (code === 0 && out.trim())
+                return finish({ installed: true, usable: true, detail: 'logged in' });
+            return finish({ installed: true, usable: false, detail: err.trim().slice(-160) || `exited ${code}` });
+        });
+    });
+}
+async function autocompleteRoutes(fastify) {
+    /**
+     * Which CLI backends are usable on THIS server (for the settings UI and the
+     * editor's ghost-text gate). "Usable" means an actual trivial turn succeeds
+     * (logged in), not merely that the binary exists — a binary without
+     * credentials previously reported true here, so the UI enabled ghost text
+     * that could only ever produce "Not logged in" errors. The real probe costs
+     * a CLI round trip, so results are cached with a TTL.
+     */
+    let statusCache = null;
+    let statusProbe = null;
+    const STATUS_TTL_MS = 5 * 60_000;
+    fastify.get('/autocomplete/status', async (_req, reply) => {
+        if (!statusCache || Date.now() - statusCache.at > STATUS_TTL_MS) {
+            if (!statusProbe) {
+                statusProbe = Promise.all([checkCliUsable('claude'), checkCliUsable('codex')])
+                    .then(([claude, codex]) => {
+                    const backends = { claude: claude.usable, codex: codex.usable };
+                    statusCache = { at: Date.now(), backends };
+                    return backends;
+                })
+                    .finally(() => { statusProbe = null; });
+            }
+            await statusProbe;
+        }
+        return reply.send({
+            enabled: true,
+            backends: statusCache.backends,
+        });
+    });
+    /**
+     * Resolve the user's local CLI paths over the reverse tunnel, so the client
+     * can enable "run on my machine". Body: { port, user, host? }.
+     * Returns { ok, reachable, claude, codex }.
+     */
+    fastify.post('/autocomplete/probe-remote', async (req, reply) => {
+        const body = (req.body ?? {});
+        const port = Number(body.port);
+        const user = typeof body.user === 'string' ? body.user.trim() : '';
+        const host = typeof body.host === 'string' && body.host.trim() ? body.host.trim() : 'localhost';
+        if (!Number.isInteger(port) || port <= 0 || !user) {
+            return reply.code(400).send({ ok: false, error: 'port and user required' });
+        }
+        const [claude, codex] = await Promise.all([
+            discoverRemoteBin(port, user, 'claude', host),
+            discoverRemoteBin(port, user, 'codex', host),
+        ]);
+        return reply.send({ ok: true, reachable: claude !== null || codex !== null, claude, codex });
+    });
+    /**
+     * Comprehensive diagnostics for the settings "AI" tab. Body: { port?, user? }.
+     * Reports the environment, whether this server's CLIs are usable (logged in),
+     * and — if tunnel params are given — whether the user's machine is reachable
+     * and which CLIs resolve there.
+     */
+    fastify.post('/autocomplete/diagnose', async (req, reply) => {
+        const body = (req.body ?? {});
+        const port = Number(body.port);
+        const user = typeof body.user === 'string' ? body.user.trim() : '';
+        const host = typeof body.host === 'string' && body.host.trim() ? body.host.trim() : 'localhost';
+        const hasTunnel = Number.isInteger(port) && port > 0 && !!user;
+        const [claude, codex] = await Promise.all([checkCliUsable('claude'), checkCliUsable('codex')]);
+        let tunnel = null;
+        if (hasTunnel) {
+            const [rc, rx] = await Promise.all([
+                discoverRemoteBin(port, user, 'claude', host),
+                discoverRemoteBin(port, user, 'codex', host),
+            ]);
+            tunnel = { configured: true, reachable: rc !== null || rx !== null, claude: rc, codex: rx };
+        }
+        return reply.send({ environment: (0, environment_1.getEnvironment)(), server: { claude, codex }, tunnel });
+    });
+    /** POST /autocomplete — SSE stream. Body may include `transport` to run the
+     *  CLI on the user's machine instead of this server. */
+    (0, server_1.registerAutocompleteRoute)(fastify, (req) => {
+        const raw = req;
+        const name = req.backend === 'codex' ? 'codex' : 'claude';
+        const t = parseTransport(raw.transport);
+        return getEngine(name, t, sanitizeTuning(name, raw));
+    });
+    // Pre-warm the default local engine at server start: the first completion
+    // after a server (re)start otherwise pays engine creation + pool spawn +
+    // warmup turns on the user's keystroke (measured ~19s cold). Booting it
+    // here moves that entirely off the request path. Best-effort; claude only
+    // (the default backend — codex spawns per-request by design).
+    void binaryAvailable('claude').then((ok) => {
+        if (ok)
+            getEngine('claude', null, { model: 'sonnet', thinkingTokens: 0 });
+    }).catch(() => { });
+    fastify.addHook('onClose', async () => {
+        disposeAutocompleteEngines();
+    });
+}

package/node-server/dist/routes/cluster.js

@@ -27,11 +27,11 @@ async function clusterRoutes(fastify) {
      * Body can include { resources } for initial resource info
      */
     fastify.post('/servers/register', async (request, reply) => {
-        const { host, port, name, secret, resources } = request.body;
+        const { host, port, name, secret, resources, allocationToken } = request.body;
         if (!host || !port) {
             return reply.code(400).send({ error: 'host and port are required' });
         }
-        const result = server_registry_1.serverRegistry.register({ host, port, name, secret, resources });
+        const result = server_registry_1.serverRegistry.register({ host, port, name, secret, resources, allocationToken });
         if (!result.success) {
             return reply.code(403).send({ error: result.error });
         }

package/node-server/dist/routes/compute.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Compute allocation API — submit and manage scheduler-backed compute.
+ *
+ * All routes live under /api/compute and are auth-protected like the rest of the
+ * API. They are no-ops (return `enabled: false`) when no scheduler is detected.
+ */
+import { FastifyInstance } from 'fastify';
+export default function computeRoutes(fastify: FastifyInstance): Promise<void>;

package/node-server/dist/routes/compute.js

@@ -0,0 +1,136 @@
+"use strict";
+/**
+ * Compute allocation API — submit and manage scheduler-backed compute.
+ *
+ * All routes live under /api/compute and are auth-protected like the rest of the
+ * API. They are no-ops (return `enabled: false`) when no scheduler is detected.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = computeRoutes;
+const os = __importStar(require("os"));
+const allocation_service_1 = require("../scheduler/allocation-service");
+function currentUser() {
+    return process.env.USER || process.env.LOGNAME || os.userInfo().username;
+}
+/** Build a JobSpec from request input, applying MVP defaults. */
+function parseSpec(x) {
+    const partition = String(x?.partition || '').trim();
+    const qos = x?.qos ? String(x.qos).trim() : undefined;
+    const account = x?.account ? String(x.account).trim() : undefined;
+    const cpus = Math.max(1, Math.floor(Number(x?.cpus) || 1));
+    const memGb = Math.max(1, Math.floor(Number(x?.memGb) || 4));
+    const gpusRaw = Math.floor(Number(x?.gpus) || 0);
+    const gpus = gpusRaw > 0 ? gpusRaw : undefined;
+    const gpuType = gpus && x?.gpuType ? String(x.gpuType).trim() || undefined : undefined;
+    const walltimeMinutes = Math.max(1, Math.floor(Number(x?.walltimeMinutes) || 120));
+    // Opt-in idle auto-release (minutes). Absent/invalid/<=0 = disabled.
+    const idleRaw = Math.floor(Number(x?.idleTimeoutMinutes) || 0);
+    const idleTimeoutMinutes = idleRaw > 0 ? idleRaw : undefined;
+    const jobName = (x?.jobName ? String(x.jobName) : `nebula-${partition || 'compute'}`)
+        .replace(/[^A-Za-z0-9._-]/g, '-')
+        .slice(0, 60) || 'nebula';
+    return { partition, qos, account, cpus, memGb, gpus, gpuType, walltimeMinutes, jobName, idleTimeoutMinutes };
+}
+async function computeRoutes(fastify) {
+    /** Whether scheduler-backed compute is available on this server. */
+    fastify.get('/compute/status', async (_req, reply) => {
+        return reply.send({
+            enabled: allocation_service_1.allocationService.isEnabled(),
+            scheduler: allocation_service_1.allocationService.getScheduler()?.name ?? null,
+        });
+    });
+    /** Allowed partitions/QoS for the current user + a live load snapshot. */
+    fastify.get('/compute/partitions', async (_req, reply) => {
+        const sched = allocation_service_1.allocationService.getScheduler();
+        if (!sched)
+            return reply.send({ enabled: false, associations: null, load: null });
+        const [associations, load] = await Promise.all([
+            sched.associations(currentUser()).catch(() => null),
+            sched.load().catch(() => null),
+        ]);
+        return reply.send({ enabled: true, associations, load });
+    });
+    /** QoS names a partition will accept (null = any). Drives the modal's QoS filter. */
+    fastify.get('/compute/partition-qos', async (req, reply) => {
+        const sched = allocation_service_1.allocationService.getScheduler();
+        if (!sched)
+            return reply.send({ allowed: null });
+        const partition = String(req.query?.partition || '').trim();
+        if (!partition)
+            return reply.send({ allowed: null });
+        const allowed = await sched.allowedQos(partition).catch(() => null);
+        return reply.send({ allowed });
+    });
+    /** Dry-run estimated start time for a prospective allocation. */
+    fastify.get('/compute/estimate', async (req, reply) => {
+        const sched = allocation_service_1.allocationService.getScheduler();
+        if (!sched)
+            return reply.code(400).send({ error: 'scheduler not available' });
+        const spec = parseSpec(req.query);
+        if (!spec.partition)
+            return reply.code(400).send({ error: 'partition is required' });
+        const estimate = await sched.estimateStart(spec);
+        return reply.send(estimate);
+    });
+    /** List current allocations (pending / running / active / ended). */
+    fastify.get('/compute/allocations', async (_req, reply) => {
+        return reply.send({ allocations: allocation_service_1.allocationService.list() });
+    });
+    /** Submit a new compute allocation. */
+    fastify.post('/compute/allocations', async (req, reply) => {
+        if (!allocation_service_1.allocationService.isEnabled()) {
+            return reply.code(400).send({ error: 'scheduler not available' });
+        }
+        const spec = parseSpec(req.body);
+        if (!spec.partition)
+            return reply.code(400).send({ error: 'partition is required' });
+        try {
+            const alloc = await allocation_service_1.allocationService.create(spec);
+            return reply.send(alloc);
+        }
+        catch (e) {
+            return reply.code(500).send({ error: e?.message || 'submit failed' });
+        }
+    });
+    /** Cancel an allocation (scancel + evict its server). */
+    fastify.delete('/compute/allocations/:id', async (req, reply) => {
+        const { id } = req.params;
+        const ok = await allocation_service_1.allocationService.cancel(id);
+        if (!ok)
+            return reply.code(404).send({ error: 'allocation not found' });
+        return reply.send({ cancelled: true });
+    });
+}

package/node-server/dist/routes/fs.js

@@ -41,7 +41,7 @@ exports.default = fsRoutes;
 const fs_service_1 = require("../fs/fs-service");
 Object.defineProperty(exports, "fsService", { enumerable: true, get: function () { return fs_service_1.fsService; } });
 const path = __importStar(require("path"));
-const os = __importStar(require("os"));
+const private_tmp_1 = require("../private-tmp");
 const nodeFs = __importStar(require("fs"));
 async function fsRoutes(fastify) {
     /**
@@ -50,7 +50,7 @@ async function fsRoutes(fastify) {
     fastify.get('/fs/list', async (request, reply) => {
         try {
             const dirPath = request.query.path || '~';
-            const result = fs_service_1.fsService.listDirectory(dirPath);
+            const result = await fs_service_1.fsService.listDirectory(dirPath);
             return reply.send(result);
         }
         catch (err) {
@@ -121,7 +121,7 @@ async function fsRoutes(fastify) {
             if (!filePath) {
                 return reply.code(400).send({ detail: 'path query parameter is required' });
             }
-            const result = fs_service_1.fsService.getFileMtime(filePath);
+            const result = await fs_service_1.fsService.getFileMtime(filePath);
             return reply.send(result);
         }
         catch (err) {
@@ -143,7 +143,7 @@ async function fsRoutes(fastify) {
             if (!filePath) {
                 return reply.code(400).send({ detail: 'path query parameter is required' });
             }
-            const result = fs_service_1.fsService.readFile(filePath);
+            const result = await fs_service_1.fsService.readFile(filePath);
             return reply.send(result);
         }
         catch (err) {
@@ -319,10 +319,27 @@ async function fsRoutes(fastify) {
                 '.zip': 'application/zip',
             };
             const contentType = mimeTypes[extension] || 'application/octet-stream';
+            // Inline viewing (?inline=1): hand the file to the browser's own viewer
+            // in a new tab instead of forcing a download. Restricted to an allowlist
+            // of types the browser renders SAFELY as data (PDF/images/media/text).
+            // HTML is intentionally excluded — served inline same-origin, its JS
+            // could read the Nebula auth token; it goes through the trust-gated
+            // /?html= view instead. nosniff stops the browser from re-interpreting a
+            // mislabeled file as something executable.
+            const wantInline = request.query.inline === '1' || request.query.inline === 'true';
+            const INLINE_OK = new Set([
+                '.pdf', '.png', '.jpg', '.jpeg', '.gif', '.svg', '.webp', '.bmp', '.ico', '.avif',
+                '.mp4', '.webm', '.mov', '.m4v', '.ogv',
+                '.mp3', '.wav', '.ogg', '.oga', '.flac', '.m4a', '.aac',
+                '.txt', '.csv', '.tsv', '.log', '.json', '.md',
+            ]);
+            const inline = wantInline && INLINE_OK.has(extension);
+            const disposition = inline ? 'inline' : 'attachment';
             const stream = nodeFs.createReadStream(normalizedPath);
             return reply
                 .header('Content-Type', contentType)
-                .header('Content-Disposition', `attachment; filename="${filename}"`)
+                .header('X-Content-Type-Options', 'nosniff')
+                .header('Content-Disposition', `${disposition}; filename="${filename}"`)
                 .header('Content-Length', stat.size)
                 .send(stream);
         }
@@ -357,7 +374,7 @@ async function fsRoutes(fastify) {
                 return reply.code(400).send({ detail: 'path is required' });
             }
             // Save the uploaded file to a temp location first
-            const tmpPath = path.join(os.tmpdir(), `upload-${Date.now()}-${data.filename}`);
+            const tmpPath = path.join((0, private_tmp_1.privateTmpDir)('uploads'), `upload-${Date.now()}-${path.basename(data.filename || 'file')}`);
             const writeStream = nodeFs.createWriteStream(tmpPath);
             await new Promise((resolve, reject) => {
                 data.file.pipe(writeStream);