@nurix/nustack 0.10.0-dev.10

package/dist/lib/local_store/pending_uploads.js

@@ -0,0 +1,76 @@
+function mapRow(row) {
+    return {
+        bindingId: row.binding_id,
+        commitId: row.commit_id,
+        manifestSha256: row.manifest_sha256 ?? null,
+        whitelistManifestSha256: row.whitelist_manifest_sha256 ?? null,
+        idempotencyKey: row.idempotency_key,
+        attempts: row.attempts,
+        nextRetryAtMs: row.next_retry_at_ms ?? null,
+        lastErrorCode: row.last_error_code ?? null,
+        lastErrorDetail: row.last_error_detail ?? null,
+        createdAtMs: row.created_at_ms,
+        updatedAtMs: row.updated_at_ms,
+    };
+}
+export function enqueueUpload(store, input) {
+    const now = Date.now();
+    store.db
+        .prepare(`INSERT INTO pending_uploads (
+                binding_id, commit_id, manifest_sha256, whitelist_manifest_sha256,
+                idempotency_key, attempts, next_retry_at_ms, created_at_ms, updated_at_ms
+            ) VALUES (
+                :binding_id, :commit_id, :manifest_sha256, :whitelist_manifest_sha256,
+                :idempotency_key, 0, :next_retry_at_ms, :created_at_ms, :updated_at_ms
+            )
+            ON CONFLICT(binding_id, commit_id) DO NOTHING`)
+        .run({
+        binding_id: input.bindingId,
+        commit_id: input.commitId,
+        manifest_sha256: input.manifestSha256 ?? null,
+        whitelist_manifest_sha256: input.whitelistManifestSha256 ?? null,
+        idempotency_key: input.idempotencyKey,
+        next_retry_at_ms: input.nextRetryAtMs ?? null,
+        created_at_ms: now,
+        updated_at_ms: now,
+    });
+    return getUpload(store, input.bindingId, input.commitId);
+}
+export function getUpload(store, bindingId, commitId) {
+    const row = store.db
+        .prepare("SELECT * FROM pending_uploads WHERE binding_id = :binding_id AND commit_id = :commit_id")
+        .get({ binding_id: bindingId, commit_id: commitId });
+    return row ? mapRow(row) : null;
+}
+export function nextDueUploads(store, nowMs) {
+    const rows = store.db
+        .prepare(`SELECT * FROM pending_uploads
+             WHERE next_retry_at_ms IS NULL OR next_retry_at_ms <= :now
+             ORDER BY created_at_ms ASC`)
+        .all({ now: nowMs });
+    return rows.map(mapRow);
+}
+export function recordUploadAttempt(store, bindingId, commitId, result = {}) {
+    store.db
+        .prepare(`UPDATE pending_uploads
+             SET attempts = attempts + 1,
+                 next_retry_at_ms = :next_retry_at_ms,
+                 last_error_code = :last_error_code,
+                 last_error_detail = :last_error_detail,
+                 updated_at_ms = :now
+             WHERE binding_id = :binding_id AND commit_id = :commit_id`)
+        .run({
+        next_retry_at_ms: result.nextRetryAtMs ?? null,
+        last_error_code: result.lastErrorCode ?? null,
+        last_error_detail: result.lastErrorDetail ?? null,
+        now: Date.now(),
+        binding_id: bindingId,
+        commit_id: commitId,
+    });
+    return getUpload(store, bindingId, commitId);
+}
+export function deleteUpload(store, bindingId, commitId) {
+    store.db
+        .prepare("DELETE FROM pending_uploads WHERE binding_id = :binding_id AND commit_id = :commit_id")
+        .run({ binding_id: bindingId, commit_id: commitId });
+}

package/dist/lib/local_store/recovery_bundles.js

@@ -0,0 +1,66 @@
+export const RECOVERY_BUNDLE_TTL_MS = 7 * 24 * 60 * 60 * 1000;
+function mapRow(row) {
+    return {
+        id: row.id,
+        bindingId: row.binding_id,
+        handoffId: row.handoff_id,
+        bundlePath: row.bundle_path,
+        manifestSha256: row.manifest_sha256,
+        state: row.state,
+        createdAtMs: row.created_at_ms,
+        expiresAtMs: row.expires_at_ms,
+    };
+}
+export function insertRecoveryBundle(store, input) {
+    const createdAtMs = input.createdAtMs ?? Date.now();
+    const expiresAtMs = input.expiresAtMs ?? createdAtMs + RECOVERY_BUNDLE_TTL_MS;
+    store.db
+        .prepare(`INSERT INTO local_recovery_bundles (
+                id, binding_id, handoff_id, bundle_path, manifest_sha256, state,
+                created_at_ms, expires_at_ms
+            ) VALUES (
+                :id, :binding_id, :handoff_id, :bundle_path, :manifest_sha256, :state,
+                :created_at_ms, :expires_at_ms
+            )`)
+        .run({
+        id: input.id,
+        binding_id: input.bindingId,
+        handoff_id: input.handoffId,
+        bundle_path: input.bundlePath,
+        manifest_sha256: input.manifestSha256,
+        state: input.state ?? "active",
+        created_at_ms: createdAtMs,
+        expires_at_ms: expiresAtMs,
+    });
+    return getRecoveryBundle(store, input.id);
+}
+export function getRecoveryBundle(store, id) {
+    const row = store.db
+        .prepare("SELECT * FROM local_recovery_bundles WHERE id = :id")
+        .get({ id });
+    return row ? mapRow(row) : null;
+}
+export function listRecoveryBundles(store, bindingId) {
+    const rows = (bindingId === undefined
+        ? store.db
+            .prepare("SELECT * FROM local_recovery_bundles ORDER BY created_at_ms ASC")
+            .all()
+        : store.db
+            .prepare("SELECT * FROM local_recovery_bundles WHERE binding_id = :binding_id ORDER BY created_at_ms ASC")
+            .all({ binding_id: bindingId }));
+    return rows.map(mapRow);
+}
+export function markRecoveryBundleState(store, id, state) {
+    store.db
+        .prepare("UPDATE local_recovery_bundles SET state = :state WHERE id = :id")
+        .run({ state, id });
+    return getRecoveryBundle(store, id);
+}
+export function listExpiredRecoveryBundles(store, nowMs) {
+    const rows = store.db
+        .prepare(`SELECT * FROM local_recovery_bundles
+             WHERE state = 'active' AND expires_at_ms <= :now
+             ORDER BY expires_at_ms ASC`)
+        .all({ now: nowMs });
+    return rows.map(mapRow);
+}

package/dist/lib/local_store/sync_vocabulary.js

@@ -0,0 +1,33 @@
+export const INBOUND_APPLICATION_STATES = [
+    "received",
+    "evaluating",
+    "no_op",
+    "technical_wait",
+    "decision_required",
+    "approved",
+    "applying",
+    "committed",
+    "undo_requested",
+    "reverted",
+    "revert_conflict",
+    "superseded",
+];
+export const BINDING_STATUSES = ["creating", "active", "paused", "failed", "removed"];
+export const LIVE_BINDING_STATUSES = ["creating", "active", "paused"];
+export const INBOUND_APPLICATION_TRANSITIONS = {
+    received: ["evaluating", "superseded"],
+    evaluating: ["no_op", "technical_wait", "decision_required", "applying", "superseded"],
+    no_op: [],
+    technical_wait: ["evaluating"],
+    decision_required: ["approved", "superseded"],
+    approved: ["applying"],
+    applying: ["committed"],
+    committed: ["undo_requested"],
+    undo_requested: ["reverted", "revert_conflict"],
+    reverted: [],
+    revert_conflict: [],
+    superseded: [],
+};
+export function isLegalApplicationTransition(from, to) {
+    return INBOUND_APPLICATION_TRANSITIONS[from].includes(to);
+}

package/dist/lib/local_store/workspace_events_cache.js

@@ -0,0 +1,54 @@
+export const DEFAULT_WORKSPACE_EVENT_KEEP_COUNT = 500;
+function mapRow(row) {
+    return {
+        bindingId: row.binding_id,
+        workspaceSequence: row.workspace_sequence,
+        eventType: row.event_type,
+        payloadJson: row.payload_json ?? null,
+        appliedAtMs: row.applied_at_ms ?? null,
+        createdAtMs: row.created_at_ms,
+    };
+}
+export function cacheWorkspaceEvents(store, bindingId, events) {
+    const now = Date.now();
+    const insert = store.db.prepare(`INSERT INTO cached_workspace_events (
+            binding_id, workspace_sequence, event_type, payload_json, applied_at_ms, created_at_ms
+        ) VALUES (
+            :binding_id, :workspace_sequence, :event_type, :payload_json, :applied_at_ms, :created_at_ms
+        )
+        ON CONFLICT(binding_id, workspace_sequence) DO NOTHING`);
+    for (const event of events) {
+        insert.run({
+            binding_id: bindingId,
+            workspace_sequence: event.workspaceSequence,
+            event_type: event.eventType,
+            payload_json: event.payloadJson ?? null,
+            applied_at_ms: event.appliedAtMs ?? null,
+            created_at_ms: now,
+        });
+    }
+}
+export function latestCachedSequence(store, bindingId) {
+    const row = store.db
+        .prepare("SELECT MAX(workspace_sequence) AS latest FROM cached_workspace_events WHERE binding_id = :binding_id")
+        .get({ binding_id: bindingId });
+    return row?.latest ?? null;
+}
+export function listCachedWorkspaceEvents(store, bindingId) {
+    const rows = store.db
+        .prepare("SELECT * FROM cached_workspace_events WHERE binding_id = :binding_id ORDER BY workspace_sequence ASC")
+        .all({ binding_id: bindingId });
+    return rows.map(mapRow);
+}
+export function pruneWorkspaceEvents(store, bindingId, keepCount = DEFAULT_WORKSPACE_EVENT_KEEP_COUNT) {
+    store.db
+        .prepare(`DELETE FROM cached_workspace_events
+             WHERE binding_id = :binding_id
+               AND workspace_sequence NOT IN (
+                   SELECT workspace_sequence FROM cached_workspace_events
+                   WHERE binding_id = :binding_id
+                   ORDER BY workspace_sequence DESC
+                   LIMIT :keep
+               )`)
+        .run({ binding_id: bindingId, keep: keepCount });
+}

package/dist/lib/loopback.js

@@ -0,0 +1,78 @@
+import { createServer } from "node:http";
+export const CALLBACK_PATH = "/callback";
+const escapeHtml = (value) => value.replace(/[&<>"']/g, (ch) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[ch] ?? ch);
+function page(title, body) {
+    return `<!doctype html><html lang="en"><head><meta charset="utf-8"><title>${escapeHtml(title)}</title>
+<style>body{font-family:system-ui,sans-serif;margin:0;display:grid;place-items:center;min-height:100vh;background:#0b0d12;color:#e8eaf0}main{max-width:32rem;padding:2rem;text-align:center}h1{font-size:1.4rem;margin:0 0 .5rem}p{color:#9aa3b2;margin:0}</style>
+</head><body><main><h1>${escapeHtml(title)}</h1><p>${escapeHtml(body)}</p></main></body></html>`;
+}
+export async function openLoopbackListener(expectedState) {
+    let settle = null;
+    const callback = new Promise((resolve, reject) => {
+        settle = { resolve, reject };
+    });
+    callback.catch(() => undefined);
+    const server = createServer((request, response) => {
+        const url = new URL(request.url ?? "/", "http://127.0.0.1");
+        if (url.pathname !== CALLBACK_PATH) {
+            response.writeHead(404, { "Content-Type": "text/plain; charset=utf-8" });
+            response.end("Not found");
+            return;
+        }
+        if (request.method !== "GET") {
+            response.writeHead(405, { "Content-Type": "text/plain; charset=utf-8", Allow: "GET" });
+            response.end("Method not allowed");
+            return;
+        }
+        const state = url.searchParams.get("state");
+        if (state !== expectedState) {
+            response.writeHead(400, { "Content-Type": "text/html; charset=utf-8" });
+            response.end(page("This sign-in did not start here", "Go back to the terminal and run `nustack login` again."));
+            return;
+        }
+        const error = url.searchParams.get("error");
+        if (error) {
+            response.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+            response.end(page("Sign-in did not complete", url.searchParams.get("error_description") ?? error));
+            settle?.reject(new Error(`The auth service refused the sign-in (${error}).`));
+            settle = null;
+            void closeServer(server);
+            return;
+        }
+        const code = url.searchParams.get("code");
+        if (!code) {
+            response.writeHead(400, { "Content-Type": "text/html; charset=utf-8" });
+            response.end(page("Sign-in did not complete", "The callback carried no code. Run `nustack login` again."));
+            return;
+        }
+        response.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+        response.end(page("Signed in", "You can close this tab and return to the terminal."));
+        settle?.resolve({ code, iss: url.searchParams.get("iss") });
+        settle = null;
+        void closeServer(server);
+    });
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(0, "127.0.0.1", () => {
+            server.off("error", reject);
+            resolve();
+        });
+    });
+    const { port } = server.address();
+    return {
+        redirectUri: `http://127.0.0.1:${port}${CALLBACK_PATH}`,
+        port,
+        callback,
+        close: async () => {
+            settle?.reject(new Error("The sign-in was abandoned before the browser answered."));
+            settle = null;
+            await closeServer(server);
+        },
+    };
+}
+async function closeServer(server) {
+    await new Promise((resolve) => {
+        server.close(() => resolve());
+        server.closeAllConnections?.();
+    });
+}

package/dist/lib/manifest.js

@@ -0,0 +1,83 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import path from "node:path";
+const MANIFEST_FILE = "nustack.service.json";
+export function manifestPath(cwd) {
+    return path.join(cwd, MANIFEST_FILE);
+}
+export function hasManifest(cwd) {
+    return existsSync(manifestPath(cwd));
+}
+export async function readConsumesEdges(cwd) {
+    const filePath = manifestPath(cwd);
+    if (!existsSync(filePath))
+        return [];
+    let manifest;
+    try {
+        manifest = JSON.parse(await readFile(filePath, "utf8"));
+    }
+    catch {
+        throw new Error(`${MANIFEST_FILE} is not valid JSON`);
+    }
+    if (!manifest || typeof manifest !== "object")
+        return [];
+    const services = manifest.services;
+    if (!Array.isArray(services))
+        return [];
+    const seen = new Set();
+    const edges = [];
+    for (const entry of services) {
+        const consumes = entry?.consumes;
+        if (!Array.isArray(consumes))
+            continue;
+        for (const raw of consumes) {
+            const edge = raw;
+            const service = typeof edge?.service === "string" ? edge.service.trim() : "";
+            if (!service || seen.has(service))
+                continue;
+            seen.add(service);
+            edges.push({
+                service,
+                via: (edge?.via ?? "http"),
+                ...(typeof edge?.endpoint === "string" ? { endpoint: edge.endpoint } : {}),
+            });
+        }
+    }
+    return edges;
+}
+export async function scaffoldManifest(cwd, repoName) {
+    const manifest = {
+        spec: "nustack.dev/v1",
+        name: repoName,
+        description: `TODO: describe ${repoName}`,
+        repository: `https://github.com/TODO/${repoName}`,
+        owner: "TODO",
+        services: [
+            {
+                name: repoName,
+                kind: "application",
+                type: "app",
+                version: "0.0.0",
+                status: "experimental",
+                description: `TODO: describe the ${repoName} application`,
+                application: { ui: "spa" },
+                consumes: [],
+            },
+        ],
+    };
+    await writeFile(manifestPath(cwd), JSON.stringify(manifest, null, 4) + "\n", "utf8");
+}
+export async function appendConsumesEdge(cwd, edge) {
+    const filePath = manifestPath(cwd);
+    const manifest = JSON.parse(await readFile(filePath, "utf8"));
+    const serviceEntry = manifest.services?.[0];
+    if (!serviceEntry)
+        throw new Error(`${MANIFEST_FILE} has no services[] entry`);
+    serviceEntry.consumes ??= [];
+    const isAlreadyDeclared = serviceEntry.consumes.some((existing) => existing.service === edge.service);
+    if (isAlreadyDeclared)
+        return false;
+    serviceEntry.consumes.push(edge);
+    await writeFile(filePath, JSON.stringify(manifest, null, 4) + "\n", "utf8");
+    return true;
+}