@nurix/nustack 0.24.0 → 0.25.2

package/dist/lib/store/wipe.js

@@ -0,0 +1,34 @@
+import { rmSync } from "node:fs";
+export const UPGRADE_COMMAND = "npm i -g @nurix/nustack@latest";
+export const WIPE_PUSH_TIMEOUT_MS = 3000;
+export function versionVerdict(found, own) {
+    if (found === own)
+        return "same";
+    return found > own ? "newer" : "older";
+}
+const releaseOf = (stamp) => `${Math.floor(stamp / 1000)}.${stamp % 1000}`;
+export class StoreTooNewError extends Error {
+    code = "STORE_TOO_NEW";
+    foundStamp;
+    ownStamp;
+    constructor(foundStamp, ownStamp) {
+        super(`This machine's NuStack store was created by NuStack ${releaseOf(foundStamp)}, newer than this CLI (${releaseOf(ownStamp)}). Update NuStack: ${UPGRADE_COMMAND}`);
+        this.name = "StoreTooNewError";
+        this.foundStamp = foundStamp;
+        this.ownStamp = ownStamp;
+    }
+}
+export async function wipeStaleStore(db, dbFile) {
+    try {
+        const pending = db.prepare("SELECT count(*) AS n FROM sync_outbox").get();
+        if (Number(pending?.n ?? 0) > 0) {
+            const { pushOutbox } = await import("../sync/client.js");
+            await pushOutbox({ db, close: () => { } }, {}, { timeoutMs: WIPE_PUSH_TIMEOUT_MS, isFinal: true });
+        }
+    }
+    catch {
+    }
+    db.close();
+    for (const file of [dbFile, `${dbFile}-wal`, `${dbFile}-shm`])
+        rmSync(file, { force: true });
+}

package/dist/lib/sync/apply.js

@@ -0,0 +1,113 @@
+import { SHARED_TABLES, sharedTable } from "./manifest.js";
+import { dropEntry, entryFor } from "./outbox.js";
+import { UNBOUND_PROJECT_PREFIX } from "../records/recordsTable.js";
+import { UNRESOLVED_PROJECT_ID } from "../local_store/routing.js";
+export function withApplying(db, fn) {
+    db.exec("BEGIN IMMEDIATE");
+    try {
+        db.prepare("INSERT OR REPLACE INTO sync_state (name, value) VALUES ('applying', '1')").run();
+        const result = fn();
+        db.prepare("DELETE FROM sync_state WHERE name = 'applying'").run();
+        db.exec("COMMIT");
+        return result;
+    }
+    catch (error) {
+        db.exec("ROLLBACK");
+        throw error;
+    }
+}
+const columnCache = new WeakMap();
+function columnsOf(db, table) {
+    let tables = columnCache.get(db);
+    if (!tables) {
+        tables = new Map();
+        columnCache.set(db, tables);
+    }
+    let columns = tables.get(table);
+    if (!columns) {
+        columns = new Set(db.prepare(`PRAGMA table_info("${table}")`).all().map((column) => column.name));
+        tables.set(table, columns);
+    }
+    return columns;
+}
+export function applyFinalRow(db, tableName, row) {
+    const table = sharedTable(tableName);
+    if (!table)
+        return;
+    const key = row[table.key];
+    if (key === null || key === undefined)
+        return;
+    const pending = entryFor(db, table.name, String(key));
+    if (pending?.op === "delete")
+        return;
+    const known = columnsOf(db, table.name);
+    let kept = null;
+    if (pending) {
+        const local = db.prepare(`SELECT * FROM "${table.name}" WHERE "${table.key}" = ?`).get(key);
+        if (local)
+            kept = Object.fromEntries(pending.changed.filter((name) => known.has(name) && name !== table.key).map((name) => [name, local[name] ?? null]));
+    }
+    const names = Object.keys(row).filter((name) => known.has(name));
+    db.prepare(`INSERT OR REPLACE INTO "${table.name}" (${names.map((name) => `"${name}"`).join(", ")}) VALUES (${names.map(() => "?").join(", ")})`).run(...names.map((name) => row[name] ?? null));
+    if (pending && kept && Object.keys(kept).length > 0) {
+        const assignments = Object.keys(kept).map((name) => `"${name}" = ?`).join(", ");
+        db.prepare(`UPDATE "${table.name}" SET ${assignments} WHERE "${table.key}" = ?`).run(...Object.values(kept), key);
+    }
+    if (pending && typeof row.row_version === "number") {
+        db.prepare("UPDATE sync_outbox SET base_version = ? WHERE table_name = ? AND row_key = ?").run(row.row_version, table.name, String(key));
+    }
+}
+export function applyTombstone(db, tombstone) {
+    const table = sharedTable(tombstone.table);
+    if (!table)
+        return;
+    db.prepare(`DELETE FROM "${table.name}" WHERE "${table.key}" = ?`).run(tombstone.key);
+    dropEntry(db, table.name, tombstone.key);
+    if (table.name === "projects")
+        deleteProjectRows(db, tombstone.key);
+}
+function deleteProjectRows(db, projectId) {
+    for (const table of SHARED_TABLES) {
+        if (!columnsOf(db, table.name).has("project_id"))
+            continue;
+        db.prepare(`DELETE FROM sync_outbox WHERE table_name = ? AND row_key IN (SELECT "${table.key}" FROM "${table.name}" WHERE project_id = ?)`).run(table.name, projectId);
+        db.prepare(`DELETE FROM "${table.name}" WHERE project_id = ?`).run(projectId);
+    }
+}
+const IS_PLACEHOLDER = `(project_id = '${UNRESOLVED_PROJECT_ID}' OR project_id LIKE '${UNBOUND_PROJECT_PREFIX}%')`;
+export function applyScope(db, scope) {
+    const organizations = JSON.stringify(scope.organizationIds);
+    const projects = JSON.stringify(scope.projectIds);
+    const inOrganizations = "(SELECT value FROM json_each(:organizations))";
+    const inProjects = "(SELECT value FROM json_each(:projects))";
+    const outside = {
+        organizations: `id NOT IN ${inOrganizations}`,
+        organization_user_map: `organization_id NOT IN ${inOrganizations}`,
+        projects: `id NOT IN ${inProjects}`,
+        sessions: `organization_id NOT IN ${inOrganizations} OR (project_id IS NOT NULL AND project_id NOT IN ${inProjects})`,
+        github_repositories: `NOT EXISTS (SELECT 1 FROM projects p WHERE p.github_installation_id = github_repositories.installation_id
+            AND p.github_repo_full_name = github_repositories.full_name)`,
+        github_items: "repository_id NOT IN (SELECT repository_id FROM github_repositories)",
+    };
+    for (const table of SHARED_TABLES) {
+        let clause = outside[table.name];
+        if (!clause && columnsOf(db, table.name).has("project_id"))
+            clause = `project_id NOT IN ${inProjects} AND NOT ${IS_PLACEHOLDER}`;
+        if (!clause)
+            continue;
+        const parameters = {};
+        if (clause.includes(":organizations"))
+            parameters.organizations = organizations;
+        if (clause.includes(":projects"))
+            parameters.projects = projects;
+        db.prepare(`DELETE FROM sync_outbox WHERE table_name = '${table.name}' AND row_key IN (SELECT "${table.key}" FROM "${table.name}" WHERE ${clause})`).run(parameters);
+        db.prepare(`DELETE FROM "${table.name}" WHERE ${clause}`).run(parameters);
+    }
+}
+export function readSyncState(db, name) {
+    const row = db.prepare("SELECT value FROM sync_state WHERE name = ?").get(name);
+    return row?.value ?? null;
+}
+export function writeSyncState(db, name, value) {
+    db.prepare("INSERT OR REPLACE INTO sync_state (name, value) VALUES (?, ?)").run(name, value);
+}

package/dist/lib/sync/client.js

@@ -0,0 +1,327 @@
+import { existsSync } from "node:fs";
+import { ensureAccessToken } from "../auth_grant.js";
+import { UNRESOLVED_PROJECT_ID } from "../local_store/routing.js";
+import { assertCredentialOrigin, resolveNuStackUrl } from "../nustack_client.js";
+import { isOriginMismatch } from "../origin_guard.js";
+import { resolveProjectId } from "../project_context.js";
+import { DEVICE_TOKEN_VARIABLE, readVariable } from "../records/environment.js";
+import { RECORD_SCHEMA_VERSION } from "../records/kinds.js";
+import { validateEnvelope } from "../records/recordValidator.js";
+import { REFUSED_ERROR_PREFIX, rekeyRecord, rootOfUnbound, selectUnboundRecords, storedPlacementOf } from "../records/recordsTable.js";
+import { SESSION_SPOOL_RETENTION_MS, listSpools, spoolOf } from "../sessions/sessionEvents.js";
+import { cliVersion } from "../store/open.js";
+import { UPGRADE_COMMAND } from "../store/wipe.js";
+import { applyFinalRow, applyScope, applyTombstone, readSyncState, withApplying, writeSyncState } from "./apply.js";
+import { CLIENT_VERSION_HEADER, PUSH_BATCH_CAP, sharedTable } from "./manifest.js";
+import { backoffEntry, deferEntry, deltaOf, dropEntry, entryFor, selectDueEntries, settleEntry } from "./outbox.js";
+const REQUEST_TIMEOUT_MS = 10_000;
+const MAX_PUSH_PASSES = 50;
+const MAX_PULL_PAGES = 500;
+const DEVICE_PROJECTION_FIELDS = ["origin", "type", "subject", "state", "outcome", "ownerAgentDefinitionId"];
+const outdatedMessage = (message) => `${message} — this CLI (${cliVersion()}) is behind the server. Update NuStack: ${UPGRADE_COMMAND}`;
+async function request(url, init, bearer, timeoutMs) {
+    try {
+        await assertCredentialOrigin(url);
+    }
+    catch (error) {
+        const code = typeof error.code === "string" ? error.code : null;
+        return { ok: false, status: 0, code, message: error instanceof Error ? error.message : String(error) };
+    }
+    let response;
+    try {
+        response = await fetch(url, {
+            method: init.method,
+            headers: {
+                ...(init.body !== undefined ? { "content-type": "application/json" } : {}),
+                authorization: `Bearer ${bearer}`,
+                [CLIENT_VERSION_HEADER]: cliVersion(),
+            },
+            ...(init.body !== undefined ? { body: JSON.stringify(init.body) } : {}),
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+    }
+    catch (error) {
+        return { ok: false, status: 0, code: null, message: `the server did not answer: ${error instanceof Error ? error.message : String(error)}` };
+    }
+    const body = (await response.json().catch(() => null));
+    if (!response.ok) {
+        const code = typeof body?.error?.code === "string" ? body.error.code : null;
+        const detail = typeof body?.error?.message === "string" ? body.error.message : typeof body?.message === "string" ? body.message : `HTTP ${response.status}`;
+        return { ok: false, status: response.status, code, message: `${code ?? `HTTP ${response.status}`}: ${detail}` };
+    }
+    if (!body || body.data === undefined || body.data === null)
+        return { ok: false, status: response.status, code: null, message: "the server answered no data" };
+    return { ok: true, data: body.data };
+}
+function personBearer(summary) {
+    let cached;
+    return () => {
+        cached ??= ensureAccessToken().then((auth) => auth?.accessToken ?? null, (error) => {
+            if (isOriginMismatch(error))
+                summary.originRefusal = error.message;
+            return null;
+        });
+        return cached;
+    };
+}
+function syncBase(globals, summary) {
+    try {
+        return resolveNuStackUrl(globals);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (isOriginMismatch(error))
+            summary.originRefusal = message;
+        summary.lastError = message;
+        return null;
+    }
+}
+async function resolveUnboundRecords(store, dueBy, now) {
+    for (const record of selectUnboundRecords(store.db)) {
+        const entry = entryFor(store.db, "harness_records", record.id);
+        if (!entry || (entry.nextAttemptAt !== null && entry.nextAttemptAt > dueBy))
+            continue;
+        const root = rootOfUnbound(record.projectId);
+        const project = root !== null && existsSync(root) ? await resolveProjectId(root, {}) : null;
+        if (project?.ok)
+            rekeyRecord(store, record, project.projectId);
+        else
+            deferEntry(store.db, entry, now);
+    }
+}
+function resolveLabelRows(store, dueBy, now) {
+    const rows = store.db
+        .prepare(`SELECT l.id, l.session_id, l.created_at FROM session_label_rows l
+             JOIN sync_outbox o ON o.table_name = 'session_label_rows' AND o.row_key = l.id
+             WHERE l.project_id = ? AND (o.next_attempt_at IS NULL OR o.next_attempt_at <= ?)`)
+        .all(UNRESOLVED_PROJECT_ID, dueBy);
+    if (rows.length === 0)
+        return;
+    const spools = listSpools();
+    for (const row of rows) {
+        const spool = spoolOf(row.session_id, spools);
+        if (spool) {
+            withApplying(store.db, () => store.db.prepare("UPDATE session_label_rows SET session_id = ?, project_id = ? WHERE id = ?").run(spool.rowId, spool.projectId, row.id));
+            continue;
+        }
+        if (now - Date.parse(row.created_at) > SESSION_SPOOL_RETENTION_MS)
+            dropEntry(store.db, "session_label_rows", row.id);
+        else {
+            const entry = entryFor(store.db, "session_label_rows", row.id);
+            if (entry)
+                deferEntry(store.db, entry, now);
+        }
+    }
+}
+function isHeld(store, entry) {
+    if (entry.op === "delete")
+        return false;
+    const table = entry.tableName === "harness_records" || entry.tableName === "session_label_rows" ? entry.tableName : null;
+    if (!table)
+        return false;
+    const row = store.db.prepare(`SELECT project_id FROM "${table}" WHERE id = ?`).get(entry.rowKey);
+    return !!row && (row.project_id === UNRESOLVED_PROJECT_ID || rootOfUnbound(row.project_id) !== null);
+}
+function isAgentRecord(store, entry) {
+    if (entry.tableName !== "harness_records")
+        return false;
+    const row = store.db.prepare("SELECT written_by_kind FROM harness_records WHERE id = ?").get(entry.rowKey);
+    return row?.written_by_kind === "agent";
+}
+function projectDelta(store, delta) {
+    if (delta.table !== "harness_records" || typeof delta.columns.payload_json !== "string")
+        return delta;
+    const row = store.db.prepare("SELECT kind FROM harness_records WHERE id = ?").get(delta.key);
+    if (row?.kind !== "obligation" || storedPlacementOf(store.db, delta.key) !== "device")
+        return delta;
+    const payload = JSON.parse(delta.columns.payload_json);
+    const projection = {};
+    for (const field of DEVICE_PROJECTION_FIELDS)
+        if (payload[field] !== undefined)
+            projection[field] = payload[field];
+    return { ...delta, columns: { ...delta.columns, payload_json: JSON.stringify(projection) } };
+}
+function recordRefusal(store, delta) {
+    if (delta.table !== "harness_records" || delta.op !== "upsert")
+        return null;
+    const row = store.db.prepare("SELECT * FROM harness_records WHERE id = ?").get(delta.key);
+    if (!row)
+        return null;
+    const payloadText = typeof delta.columns.payload_json === "string" ? delta.columns.payload_json : String(row.payload_json);
+    let payload;
+    try {
+        payload = JSON.parse(payloadText);
+    }
+    catch {
+        return `${REFUSED_ERROR_PREFIX}VALIDATION_FAILED: the payload is not JSON`;
+    }
+    const envelope = {
+        kind: row.kind,
+        schemaVersion: RECORD_SCHEMA_VERSION,
+        projectId: row.project_id,
+        ...(row.session_id !== null ? { sessionId: row.session_id } : {}),
+        ...(row.plan_anchor !== null ? { planAnchor: row.plan_anchor } : {}),
+        naturalKey: row.natural_key,
+        payload,
+        occurredAt: row.occurred_at,
+    };
+    const verdict = validateEnvelope(envelope);
+    return verdict.isValid ? null : `${REFUSED_ERROR_PREFIX}VALIDATION_FAILED: ${verdict.errors[0] ?? "the row fails the records schema"}`;
+}
+export function pushDeltas(base, deltas, bearer, timeoutMs = REQUEST_TIMEOUT_MS) {
+    return request(`${base}/api/v2/sync/push`, { method: "POST", body: { deltas } }, bearer, timeoutMs);
+}
+async function pushBatch(store, base, batch, bearer, summary, timeoutMs) {
+    const answer = await pushDeltas(base, batch.map((item) => item.delta), bearer, timeoutMs);
+    const now = Date.now();
+    if (!answer.ok) {
+        if (answer.status === 426) {
+            summary.outdated = outdatedMessage(answer.message);
+            summary.lastError = summary.outdated;
+            return false;
+        }
+        for (const item of batch)
+            backoffEntry(store.db, item.entry, answer.message, now);
+        summary.lastError = answer.message;
+        return true;
+    }
+    for (const refusal of answer.data.refused ?? []) {
+        const item = batch[refusal.index];
+        if (!item)
+            continue;
+        const error = `${REFUSED_ERROR_PREFIX}${refusal.code}: ${refusal.message}`;
+        backoffEntry(store.db, item.entry, error, now);
+        summary.refused += 1;
+        summary.lastError = error;
+    }
+    const accepted = answer.data.rows ?? [];
+    withApplying(store.db, () => {
+        for (const result of accepted) {
+            const item = batch[result.index];
+            if (!item)
+                continue;
+            settleEntry(store.db, item.entry);
+            const table = sharedTable(result.table);
+            if (!result.row || !table)
+                continue;
+            if (String(result.row[table.key]) !== result.key)
+                store.db.prepare(`DELETE FROM "${table.name}" WHERE "${table.key}" = ?`).run(result.key);
+            applyFinalRow(store.db, result.table, result.row);
+        }
+    });
+    summary.sent += accepted.length;
+    return true;
+}
+async function pushPass(store, base, summary, dueBy, person, timeoutMs) {
+    const now = Date.now();
+    await resolveUnboundRecords(store, dueBy, now);
+    resolveLabelRows(store, dueBy, now);
+    const deviceToken = readVariable(DEVICE_TOKEN_VARIABLE);
+    const groups = { device: [], person: [] };
+    let taken = 0;
+    for (const entry of selectDueEntries(store.db, dueBy)) {
+        if (isHeld(store, entry))
+            continue;
+        const isDevice = isAgentRecord(store, entry);
+        if (isDevice && deviceToken === null)
+            continue;
+        const delta = deltaOf(store.db, entry);
+        if (delta === null) {
+            dropEntry(store.db, entry.tableName, entry.rowKey);
+            continue;
+        }
+        const projected = projectDelta(store, delta);
+        const invalid = recordRefusal(store, projected);
+        if (invalid !== null) {
+            backoffEntry(store.db, entry, invalid, now);
+            summary.refused += 1;
+            summary.lastError = invalid;
+            continue;
+        }
+        (isDevice ? groups.device : groups.person).push({ entry, delta: projected });
+        taken += 1;
+    }
+    for (const [credential, list] of Object.entries(groups)) {
+        if (list.length === 0)
+            continue;
+        const bearer = credential === "device" ? deviceToken : await person();
+        for (let start = 0; start < list.length; start += PUSH_BATCH_CAP) {
+            const batch = list.slice(start, start + PUSH_BATCH_CAP);
+            if (bearer === null) {
+                const error = summary.originRefusal ?? "this device is signed out";
+                for (const item of batch)
+                    backoffEntry(store.db, item.entry, error, Date.now());
+                summary.lastError = error;
+                continue;
+            }
+            if (!(await pushBatch(store, base, batch, bearer, summary, timeoutMs)))
+                return 0;
+        }
+    }
+    return taken;
+}
+export async function pushOutbox(store, globals, options = {}) {
+    const summary = { sent: 0, refused: 0, lastError: null, originRefusal: null, outdated: null };
+    const base = syncBase(globals, summary);
+    if (base === null)
+        return summary;
+    const person = personBearer(summary);
+    const timeoutMs = options.timeoutMs ?? REQUEST_TIMEOUT_MS;
+    const passes = options.isFinal ? 1 : MAX_PUSH_PASSES;
+    for (let pass = 0; pass < passes; pass += 1) {
+        options.onPass?.();
+        const dueBy = pass === 0 && (options.isForeground || options.isFinal) ? Number.MAX_SAFE_INTEGER : Date.now();
+        if ((await pushPass(store, base, summary, dueBy, person, timeoutMs)) === 0 || summary.outdated)
+            break;
+    }
+    return summary;
+}
+export function pullCursor(store) {
+    return Number(readSyncState(store.db, "cursor") ?? 0);
+}
+function applyPage(store, page) {
+    withApplying(store.db, () => {
+        for (const pulled of page.rows ?? [])
+            applyFinalRow(store.db, pulled.table, pulled.row);
+        for (const tombstone of page.tombstones ?? [])
+            applyTombstone(store.db, tombstone);
+        if (!page.hasMore && page.scope) {
+            applyScope(store.db, page.scope);
+            writeSyncState(store.db, "scope", JSON.stringify(page.scope));
+        }
+        writeSyncState(store.db, "cursor", String(page.cursor));
+    });
+}
+export async function pullAll(store, globals, options = {}) {
+    const summary = { rows: 0, tombstones: 0, cursor: pullCursor(store), isReset: false, lastError: null, originRefusal: null, outdated: null };
+    const base = syncBase(globals, summary);
+    if (base === null)
+        return summary;
+    const bearer = await personBearer(summary)();
+    if (bearer === null) {
+        summary.lastError = summary.originRefusal ?? "this device is signed out";
+        return summary;
+    }
+    for (let page = 0; page < MAX_PULL_PAGES; page += 1) {
+        const answer = await request(`${base}/api/v2/sync/pull?cursor=${summary.cursor}`, { method: "GET" }, bearer, options.timeoutMs ?? REQUEST_TIMEOUT_MS);
+        if (!answer.ok) {
+            if (answer.status === 410 && !summary.isReset) {
+                summary.isReset = true;
+                summary.cursor = 0;
+                withApplying(store.db, () => writeSyncState(store.db, "cursor", "0"));
+                continue;
+            }
+            summary.lastError = answer.status === 426 ? outdatedMessage(answer.message) : answer.message;
+            if (answer.status === 426)
+                summary.outdated = summary.lastError;
+            return summary;
+        }
+        applyPage(store, answer.data);
+        summary.rows += answer.data.rows?.length ?? 0;
+        summary.tombstones += answer.data.tombstones?.length ?? 0;
+        summary.cursor = answer.data.cursor;
+        if (!answer.data.hasMore)
+            break;
+    }
+    return summary;
+}

package/dist/lib/sync/endpoint.js

@@ -0,0 +1,26 @@
+import { resolveNuStackOrigin } from "../nustack_client.js";
+import { resolveProjectId } from "../project_context.js";
+import { readProjectContract } from "../project_contract.js";
+import { originOf } from "../origin_guard.js";
+export async function resolveDoor(root, globals, projectFlag) {
+    const project = await resolveProjectId(root, projectFlag ? { project: projectFlag } : {});
+    if (!project.ok)
+        return { kind: "store", projectId: null, root, reason: "this folder is not bound to a Project" };
+    const contract = await readProjectContract(root);
+    const door = contract.door;
+    if (door === null)
+        return { kind: "store", projectId: project.projectId, root, reason: "the harness manifest configures no door" };
+    let origin;
+    try {
+        origin = resolveNuStackOrigin(globals, root).url;
+    }
+    catch (error) {
+        return { kind: "store", projectId: project.projectId, root, reason: error instanceof Error ? error.message : String(error) };
+    }
+    if (door !== undefined && contract.doorSource === "contract" && originOf(door) !== originOf(origin)) {
+        const reason = `the contract's door ${door} is not on the resolved origin ${origin}; nothing is sent`;
+        process.stderr.write(`nustack: ${reason}\n`);
+        return { kind: "store", projectId: project.projectId, root, reason };
+    }
+    return { kind: "door", projectId: project.projectId, doorUrl: door ?? origin, isPlatformDefault: door === undefined, root };
+}

package/dist/lib/sync/manifest.js

@@ -0,0 +1,80 @@
+export const SHARED_TABLES = [
+    { name: "organizations", key: "id" },
+    { name: "users", key: "id" },
+    { name: "organization_user_map", key: "id" },
+    { name: "projects", key: "id" },
+    { name: "project_local_bindings", key: "id" },
+    {
+        name: "harness_records",
+        key: "id",
+        machineColumns: [
+            "id",
+            "project_id",
+            "kind",
+            "schema_version",
+            "natural_key",
+            "idempotency_key",
+            "session_id",
+            "plan_anchor",
+            "payload_json",
+            "occurred_at",
+        ],
+    },
+    {
+        name: "project_files",
+        key: "id",
+        machineColumns: [
+            "id",
+            "project_id",
+            "ref",
+            "path",
+            "type",
+            "status",
+            "body_sha256",
+            "git_blob_sha",
+            "body_bytes",
+            "git_mode",
+            "is_opaque",
+            "settlement_id",
+            "record_genre",
+            "fields_json",
+            "record_date",
+            "parse_version",
+            "commit_sha",
+        ],
+    },
+    {
+        name: "project_commits",
+        key: "id",
+        machineColumns: ["id", "project_id", "ref", "sha", "parent_shas_json", "author_name", "author_email", "subject", "committed_at"],
+    },
+    { name: "github_repositories", key: "repository_id" },
+    { name: "github_items", key: "id" },
+    { name: "sessions", key: "id" },
+    {
+        name: "session_label_rows",
+        key: "id",
+        machineColumns: [
+            "id",
+            "session_id",
+            "project_id",
+            "agent_type",
+            "path",
+            "estimated_tokens",
+            "returned_tokens",
+            "handler",
+            "check_result",
+            "is_bypass_used",
+            "latency_ms",
+            "tokens_kept_out",
+            "created_at",
+        ],
+    },
+    { name: "harness_project_versions", key: "id" },
+];
+export const PUSH_BATCH_CAP = 200;
+export const CLIENT_VERSION_HEADER = "X-NuStack-Client";
+export const MAIN_REF = "main";
+export function sharedTable(name) {
+    return SHARED_TABLES.find((table) => table.name === name) ?? null;
+}