@wenathlan/saddle 2.0.151 → 2.0.152

package/dist/vite.config.d.ts

@@ -0,0 +1,3 @@
+/** Style: saddle Sol — the absorbed console surface on the family theme machinery: static-first vite build that emits the hashed bundles straight at the app root, with a repository-scoped base path and preview-safe host handling. */
+declare const _default: import("vite").UserConfig;
+export default _default;

package/dist/vite.config.js

@@ -0,0 +1,43 @@
+/** Style: saddle Sol — the absorbed console surface on the family theme machinery: static-first vite build that emits the hashed bundles straight at the app root, with a repository-scoped base path and preview-safe host handling. */
+import path from 'node:path';
+import tailwindcss from '@tailwindcss/vite';
+import react from '@vitejs/plugin-react';
+import { defineConfig } from 'vite';
+function themeBasePath(value) {
+    const candidate = value?.trim() || '/';
+    if (candidate === '.' || candidate === './')
+        return './';
+    return candidate === '/' ? candidate : `/${candidate.replace(/^\/+|\/+$/g, '')}/`;
+}
+export default defineConfig({
+    base: themeBasePath(process.env.VITE_BASE_PATH),
+    plugins: [react(), tailwindcss()],
+    resolve: {
+        alias: {
+            // the theme sources live in the Sol folder of this app root.
+            '@': path.resolve(import.meta.dirname, 'Sol'),
+            // The playground consumes the engine source here so the build never
+            // depends on a prebuilt dist directory.
+            '@saddle/isolation': path.resolve(import.meta.dirname, 'isolation.ts'),
+        },
+    },
+    root: import.meta.dirname,
+    envDir: import.meta.dirname,
+    build: {
+        outDir: path.resolve(import.meta.dirname, '.'),
+        emptyOutDir: false,
+        assetsDir: '',
+    },
+    /** the theme sources live in the Sol folder of this app root: the pages import
+     * the root engine logics (api, auth, db, mesh, sandbox) across the theme
+     * boundary, and the playground consumes the root isolation module, so the
+     * dev server allows this single root. */
+    server: {
+        fs: {
+            allow: [import.meta.dirname],
+        },
+        host: true,
+        strictPort: false,
+        allowedHosts: true,
+    },
+});

package/dist/vitest.config.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vite").UserConfig;
+export default _default;

package/dist/vitest.config.js

@@ -0,0 +1,25 @@
+import { defineConfig } from "vitest/config";
+export default defineConfig({
+    test: {
+        environment: "node",
+        include: ["tests/*.test.ts"],
+        globals: true,
+        testTimeout: 15000,
+        coverage: {
+            provider: "v8",
+            reporter: ["text", "json", "html"],
+            include: ["src/**/*.ts"],
+            exclude: [
+                "tests/*.test.ts",
+                "scripts/**",
+                "web/**",
+                "production/**",
+                "docs/**",
+                "node_modules/**",
+                "dist/**",
+                "coverage/**",
+            ],
+            thresholds: { lines: 60, functions: 50, branches: 50, statements: 60 },
+        },
+    },
+});

package/dist/webserver.d.ts

@@ -0,0 +1,166 @@
+#!/usr/bin/env node
+/**
+ * webserver.ts — self-hosted node api for the saddle web console (the merged e2ugh sandbox surface, v7-BACK).
+ *
+ * pure node:http, zero dependencies, esm. the server serves the react
+ * spa build (the hashed bundles vite emits straight at the app root,
+ * produced once by "npm run web:build";
+ * content types parsed from web/mime.types at boot) with the index.html
+ * fallback for client routes, and it exposes the /api/v1 contract:
+ * health, spec catalogs read from the repository json files, in-memory
+ * sandboxes with the created ->
+ * running state machine persisted to sqlite, exec through the very
+ * same browser-pure dispatcher (sandbox.ts) with the persistent
+ * per-sandbox workspace filesystem (sandboxfiles table, quota capped,
+ * data stays with the sandbox id across restarts), the auth surface
+ * (register/login/logout/me backed by scrypt and sessions in db.ts),
+ * the edge execution plane (the modality catalog census, the probed
+ * lane report and the server-side edge runs riding the modality
+ * lanes), the signed mesh surface (register/heartbeat/nodes verified by
+ * mesh.ts), the admin surface (overview/users/nodes/sandboxes/audit)
+ * and the events poll for the dashboard. per the project rules there
+ * is no serverless function anywhere: this file is the whole backend
+ * and runs on any plain node host (docker, vps, caddy reverse proxy).
+ * the backend sources (server.ts, db.ts, auth.ts, mesh.ts, sandbox.ts)
+ * stay at the app root beside the served root, so the extension denylist
+ * keeps them unreachable by the static resolver.
+ *
+ * contexts (28): types, httpserver, portselection, noderole,
+ * staticfiles, mimetypes, contenttypes, cacheheaders, securityheaders,
+ * cors, jsonio, apierrors, health, speccatalogs, specscache, edgeplane,
+ * authroutes, sandboxes, sandboxfs, statemachine, ttlreaper,
+ * execendpoint, filesroutes, meshroutes, adminroutes, eventsroute,
+ * requestlogging, gracefulshutdown.
+ *
+ * rules: lowercase identifiers, english jsdoc in third person, no emoji,
+ * try/catch on every fallible path, standardized {error:{code,message}}
+ * json failures, no hardcoded localhost address, host and port resolved
+ * once at boot from argv/env with a random 30000-59999 default.
+ */
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { SandboxFs, SandboxState } from './sandbox.ts';
+import type { WorkspaceUsage } from './db.ts';
+import type { SessionUser } from './auth.ts';
+/** sandbox creation request carried by POST /api/v1/sandboxes; the cpu
+ * model, gpu and mig values come from the reviewed catalogs. the
+ * declaration fields (base, os, arch, form, networking, vgpu, diskgb,
+ * timeoutseconds) ride the sandboxprofile.ts plane: any of them present
+ * switches the request to the resolved spec path, none keeps the exact
+ * legacy behavior. */
+export type SandboxCreateBody = {
+    model?: string;
+    vcpus?: number;
+    ramgb?: number;
+    gpu?: string;
+    mig?: string;
+    quotamb?: number;
+    base?: string;
+    os?: string;
+    arch?: string;
+    form?: string;
+    networking?: string;
+    vgpu?: boolean;
+    diskgb?: number;
+    timeoutseconds?: number;
+};
+/** the resolved sandbox spec stored on the record and echoed by the views.
+ * the declaration fields stay optional so legacy rows (and legacy
+ * callers) keep their shape untouched. */
+export type SandboxSpecView = {
+    model: string;
+    vcpus: number;
+    ramgb: number;
+    gpu: string;
+    mig: string;
+    os?: string;
+    arch?: string;
+    form?: string;
+    networking?: string;
+    vgpu?: boolean;
+    diskgb?: number | null;
+    timeoutseconds?: number;
+};
+/** the in-memory sandbox record: the api lifecycle fields plus the
+ * private engine state consumed by dispatch and the dispatcher
+ * filesystem context bound to the sqlite workspace table. */
+export type SandboxRecord = {
+    id: string;
+    userid: string;
+    state: 'created' | 'running' | 'destroyed' | 'expired';
+    spec: SandboxSpecView;
+    createdat: number;
+    startedat: number | null;
+    expiresat: number;
+    execcount: number;
+    lastcommand: string | null;
+    usage: WorkspaceUsage;
+    engine: SandboxState;
+    fscontext: {
+        quota: number;
+        fs: SandboxFs;
+    };
+};
+/** the json-safe status document answered by the sandbox routes. */
+export type SandboxPublicView = {
+    id: string;
+    state: string;
+    model: string;
+    vcpus: number;
+    ramgb: number;
+    gpu: string;
+    mig: string;
+    spec: SandboxSpecView;
+    createdAt: string;
+    startedAt: string | null;
+    expiresAt: string;
+    ttlSeconds: number;
+    execCount: number;
+    lastCommand: string | null;
+    usage: WorkspaceUsage;
+};
+/** one shelf row answered by GET /api/v1/sandboxes. */
+export type SandboxShelfRow = {
+    id: string;
+    state: string;
+    model: string;
+    vcpus: number;
+    ramgb: number;
+    gpu: string;
+    createdAt: string;
+    expiresAt: string | null;
+    files: number;
+    bytes: number;
+    resumable: boolean;
+};
+/**
+ * in-memory sandbox store: id -> record. the record carries the api
+ * lifecycle fields plus the private engine state consumed by dispatch
+ * and the owning userid persisted in the sandboxes table.
+ */
+declare const sandboxes: Map<string, SandboxRecord>;
+/**
+ * creates a sandbox record: id, the created -> running state machine with
+ * the 125 ms firecracker ramp, the resolved spec, the owning user and
+ * the dispatcher state built by createsandboxstate. the row is mirrored
+ * into the sqlite sandboxes table. malformed requests throw errors
+ * carrying status and code fields consumed by the route handler.
+ *
+ * @param body the creation request; the cpu
+ *   model comes from the reviewed catalog, quotamb picks the persistent
+ *   workspace quota (4-256 MiB).
+ * @param user the authenticated owner.
+ * @returns the stored sandbox record.
+ */
+declare function createsandbox(body: SandboxCreateBody, user: SessionUser): SandboxRecord;
+/**
+ * handles one /api/v1 request.
+ *
+ * @param req the incoming request.
+ * @param res the outgoing response.
+ * @param url the parsed request url.
+ * @returns resolves when the response is written.
+ */
+declare function handleapi(req: IncomingMessage, res: ServerResponse, url: URL): Promise<void>;
+/** the http server: static files plus the /api/v1 router. */
+declare const server: import("node:http").Server<typeof IncomingMessage, typeof ServerResponse>;
+export { server, sandboxes, createsandbox, handleapi };