@xano/cli 1.3.3 → 1.3.4

package/dist/utils/object-fetch.d.ts

@@ -0,0 +1,86 @@
+import { type SyncFileEntry, type SyncTargetIdentity, type SyncTargetState } from './sync-state.js';
+export declare const PER_OBJECT_FETCH_LIMIT = 25;
+export declare const PER_OBJECT_CONCURRENCY = 6;
+export type ObjectType = 'addon' | 'agent' | 'function' | 'query' | 'table' | 'task' | 'tool';
+export interface TypeSpec {
+    hasBranchField: boolean;
+    listPath: (workspaceId: string, extra?: {
+        groupId?: number;
+    }) => string;
+    objectPath: (workspaceId: string, id: number, extra?: {
+        groupId?: number;
+    }) => string;
+}
+export declare const OBJECT_TYPE_SPECS: Record<ObjectType, TypeSpec>;
+export declare function isObjectType(type: string): type is ObjectType;
+export declare function typesWithoutBranchField(types: string[]): string[];
+/**
+ * Insert a guid line before the final `}`, matching `syncGuidToFile`.
+ * A blank line is inserted before it when the previous non-empty line is a
+ * closing `}` or `]` (the multidoc export's layout, measured in Phase 0b).
+ */
+export declare function insertGuidLine(content: string, guid: string): string;
+export declare function restoreGuidFromLocal(remoteContent: string, localContent: string): string;
+export declare function readXanoscript(body: unknown): {
+    branch?: string;
+    status: string;
+    text: string;
+} | {
+    error: string;
+};
+export interface ResolvedObjectId {
+    groupId?: number;
+    id: number;
+}
+export type ObjectGet = (pathname: string, query?: Record<string, string>) => Promise<{
+    json: unknown;
+    ok: boolean;
+    status: number;
+}>;
+export declare function lookupObjectId(get: ObjectGet, workspaceId: string, parsed: {
+    apiGroup?: string;
+    name: string;
+    type: string;
+    verb?: string;
+}): Promise<null | ResolvedObjectId>;
+export interface PushedObject {
+    content: string;
+    filePath: string;
+    relPath: string;
+}
+export interface FetchFormattedResult {
+    content: string;
+    filePath: string;
+    id: number;
+    relPath: string;
+}
+export type FetchFormattedFailure = {
+    error: string;
+    filePath: string;
+};
+export declare function canUsePerObjectFetch(args: {
+    isLiveBranch: boolean;
+    limit?: number;
+    pushed: PushedObject[];
+}): {
+    ok: false;
+    reason: string;
+} | {
+    ok: true;
+};
+export declare function fetchFormattedObjects(args: {
+    get: ObjectGet;
+    isLiveBranch: boolean;
+    limit?: number;
+    pushed: PushedObject[];
+    state: null | SyncTargetState;
+    target: SyncTargetIdentity;
+    workspaceId: string;
+}): Promise<{
+    ids: Record<string, SyncFileEntry>;
+    ok: true;
+    results: FetchFormattedResult[];
+} | {
+    ok: false;
+    reason: string;
+}>;

package/dist/utils/object-fetch.js

@@ -0,0 +1,265 @@
+import { mapWithConcurrency } from './concurrency.js';
+import { buildDocumentKey, parseDocument } from './document-parser.js';
+import { normalizeListResponse } from './paging.js';
+export const PER_OBJECT_FETCH_LIMIT = 25;
+export const PER_OBJECT_CONCURRENCY = 6;
+export const OBJECT_TYPE_SPECS = {
+    addon: {
+        hasBranchField: true,
+        listPath: (workspaceId) => `/workspace/${workspaceId}/addon`,
+        objectPath: (workspaceId, id) => `/workspace/${workspaceId}/addon/${id}`,
+    },
+    agent: {
+        hasBranchField: false,
+        listPath: (workspaceId) => `/workspace/${workspaceId}/agent`,
+        objectPath: (workspaceId, id) => `/workspace/${workspaceId}/agent/${id}`,
+    },
+    function: {
+        hasBranchField: true,
+        listPath: (workspaceId) => `/workspace/${workspaceId}/function`,
+        objectPath: (workspaceId, id) => `/workspace/${workspaceId}/function/${id}`,
+    },
+    query: {
+        hasBranchField: false,
+        listPath: (workspaceId, extra) => extra?.groupId === undefined
+            ? `/workspace/${workspaceId}/apigroup`
+            : `/workspace/${workspaceId}/apigroup/${extra.groupId}/api`,
+        objectPath: (workspaceId, id, extra) => `/workspace/${workspaceId}/apigroup/${extra?.groupId}/api/${id}`,
+    },
+    table: {
+        hasBranchField: false,
+        listPath: (workspaceId) => `/workspace/${workspaceId}/table`,
+        objectPath: (workspaceId, id) => `/workspace/${workspaceId}/table/${id}`,
+    },
+    task: {
+        hasBranchField: true,
+        listPath: (workspaceId) => `/workspace/${workspaceId}/task`,
+        objectPath: (workspaceId, id) => `/workspace/${workspaceId}/task/${id}`,
+    },
+    tool: {
+        hasBranchField: true,
+        listPath: (workspaceId) => `/workspace/${workspaceId}/tool`,
+        objectPath: (workspaceId, id) => `/workspace/${workspaceId}/tool/${id}`,
+    },
+};
+const GUID_REGEX = /guid\s*=\s*(["'])([^"']*)\1/;
+export function isObjectType(type) {
+    return type in OBJECT_TYPE_SPECS;
+}
+export function typesWithoutBranchField(types) {
+    return types.filter((type) => isObjectType(type) && !OBJECT_TYPE_SPECS[type].hasBranchField);
+}
+/**
+ * Insert a guid line before the final `}`, matching `syncGuidToFile`.
+ * A blank line is inserted before it when the previous non-empty line is a
+ * closing `}` or `]` (the multidoc export's layout, measured in Phase 0b).
+ */
+export function insertGuidLine(content, guid) {
+    if (GUID_REGEX.test(content)) {
+        return content.replace(GUID_REGEX, `guid = "${guid}"`);
+    }
+    const lines = content.split('\n');
+    let insertIndex = -1;
+    for (let i = lines.length - 1; i >= 0; i--) {
+        if (lines[i].trim() === '}') {
+            insertIndex = i;
+            break;
+        }
+    }
+    if (insertIndex === -1)
+        return content;
+    let indent = '  ';
+    let previousNonEmpty = '';
+    for (let i = insertIndex - 1; i >= 0; i--) {
+        if (lines[i].trim()) {
+            previousNonEmpty = lines[i].trim();
+            const indentMatch = lines[i].match(/^(\s+)/);
+            if (indentMatch)
+                indent = indentMatch[1];
+            break;
+        }
+    }
+    const guidLine = `${indent}guid = "${guid}"`;
+    if (previousNonEmpty === '}' || previousNonEmpty === ']') {
+        lines.splice(insertIndex, 0, '', guidLine);
+    }
+    else {
+        lines.splice(insertIndex, 0, guidLine);
+    }
+    return lines.join('\n');
+}
+export function restoreGuidFromLocal(remoteContent, localContent) {
+    const localGuid = localContent.match(GUID_REGEX);
+    if (!localGuid)
+        return remoteContent;
+    if (GUID_REGEX.test(remoteContent))
+        return remoteContent;
+    return insertGuidLine(remoteContent, localGuid[2]);
+}
+export function readXanoscript(body) {
+    if (!body || typeof body !== 'object')
+        return { error: 'response is not an object' };
+    const record = body;
+    const xs = record.xanoscript;
+    if (!xs || typeof xs !== 'object')
+        return { error: 'xanoscript is missing' };
+    const script = xs;
+    if (script.status !== 'ok' || typeof script.value !== 'string') {
+        return { error: `xanoscript.status is ${String(script.status)}` };
+    }
+    return {
+        branch: typeof record.branch === 'string' ? record.branch : undefined,
+        status: 'ok',
+        text: script.value,
+    };
+}
+function itemsOf(json) {
+    try {
+        return normalizeListResponse(json, [
+            'functions',
+            'tables',
+            'tasks',
+            'agents',
+            'tools',
+            'addons',
+            'apigroups',
+            'apis',
+        ]).items.filter((item) => typeof item === 'object' && item !== null);
+    }
+    catch {
+        return [];
+    }
+}
+async function searchExact(get, pathname, name, extraMatch) {
+    const response = await get(pathname, { include_draft: 'false', page: '1', per_page: '50', search: name });
+    if (!response.ok)
+        return null;
+    const matches = itemsOf(response.json).filter((item) => item.name === name && (extraMatch ? extraMatch(item) : true));
+    if (matches.length !== 1 || typeof matches[0].id !== 'number')
+        return null;
+    return matches[0];
+}
+export async function lookupObjectId(get, workspaceId, parsed) {
+    if (!isObjectType(parsed.type))
+        return null;
+    const spec = OBJECT_TYPE_SPECS[parsed.type];
+    if (parsed.type === 'query') {
+        if (!parsed.apiGroup)
+            return null;
+        const group = await searchExact(get, spec.listPath(workspaceId), parsed.apiGroup);
+        if (!group || typeof group.id !== 'number')
+            return null;
+        const verb = parsed.verb ? String(parsed.verb).toUpperCase() : undefined;
+        const api = await searchExact(get, spec.listPath(workspaceId, { groupId: group.id }), parsed.name, (item) => verb ? String(item.verb ?? '').toUpperCase() === verb : true);
+        if (!api || typeof api.id !== 'number')
+            return null;
+        return { groupId: group.id, id: api.id };
+    }
+    const found = await searchExact(get, spec.listPath(workspaceId), parsed.name);
+    if (!found || typeof found.id !== 'number')
+        return null;
+    return { id: found.id };
+}
+export function canUsePerObjectFetch(args) {
+    const limit = args.limit ?? PER_OBJECT_FETCH_LIMIT;
+    if (args.pushed.length === 0)
+        return { ok: false, reason: 'no pushed documents' };
+    if (args.pushed.length > limit) {
+        return { ok: false, reason: `push has ${args.pushed.length} documents (limit ${limit})` };
+    }
+    const types = new Set();
+    for (const entry of args.pushed) {
+        const parsed = parseDocument(entry.content);
+        if (!parsed || !isObjectType(parsed.type)) {
+            return { ok: false, reason: `type ${parsed?.type ?? 'unknown'} is not in the per-object table` };
+        }
+        types.add(parsed.type);
+    }
+    if (!args.isLiveBranch) {
+        const missing = typesWithoutBranchField([...types]);
+        if (missing.length > 0) {
+            return { ok: false, reason: `types without a branch field on a non-live branch: ${missing.join(', ')}` };
+        }
+    }
+    return { ok: true };
+}
+export async function fetchFormattedObjects(args) {
+    const gate = canUsePerObjectFetch({ isLiveBranch: args.isLiveBranch, limit: args.limit, pushed: args.pushed });
+    if (!gate.ok)
+        return gate;
+    const ids = {};
+    const resolved = [];
+    for (const entry of args.pushed) {
+        const parsed = parseDocument(entry.content);
+        if (!parsed || !isObjectType(parsed.type)) {
+            return { ok: false, reason: `unparseable document ${entry.relPath}` };
+        }
+        const key = buildDocumentKey(parsed.type, parsed.name, parsed.verb, parsed.apiGroup);
+        const recorded = args.state?.files[entry.relPath];
+        let id;
+        let groupId;
+        const cachedId = recorded?.id !== undefined && recorded.key === key ? recorded.id : undefined;
+        if (parsed.type === 'query' || cachedId === undefined) {
+            // Sequential: stop on the first miss instead of firing every lookup.
+            // eslint-disable-next-line no-await-in-loop
+            const lookedUp = await lookupObjectId(args.get, args.workspaceId, parsed);
+            if (!lookedUp)
+                return { ok: false, reason: `could not look up id for ${entry.relPath}` };
+            id = cachedId ?? lookedUp.id;
+            groupId = lookedUp.groupId;
+        }
+        else {
+            id = cachedId;
+        }
+        resolved.push({ ...entry, groupId, id, key });
+    }
+    const fetched = await mapWithConcurrency(resolved, PER_OBJECT_CONCURRENCY, async (entry) => {
+        const parsed = parseDocument(entry.content);
+        const spec = OBJECT_TYPE_SPECS[parsed.type];
+        const pathname = spec.objectPath(args.workspaceId, entry.id, { groupId: entry.groupId });
+        const response = await args.get(pathname, { include_draft: 'false', include_xanoscript: 'true' });
+        if (!response.ok) {
+            return { error: `HTTP ${response.status} for ${entry.relPath}`, filePath: entry.filePath };
+        }
+        const xs = readXanoscript(response.json);
+        if ('error' in xs) {
+            return { error: `${entry.relPath}: ${xs.error}`, filePath: entry.filePath };
+        }
+        if (spec.hasBranchField && xs.branch !== args.target.branch) {
+            return {
+                error: `${entry.relPath}: branch ${xs.branch ?? '(missing)'} != ${args.target.branch}`,
+                filePath: entry.filePath,
+            };
+        }
+        const restored = restoreGuidFromLocal(xs.text, entry.content);
+        const restoredParsed = parseDocument(restored);
+        if (!restoredParsed) {
+            return { error: `${entry.relPath}: fetched document did not parse`, filePath: entry.filePath };
+        }
+        const restoredKey = buildDocumentKey(restoredParsed.type, restoredParsed.name, restoredParsed.verb, restoredParsed.apiGroup);
+        if (restoredKey !== entry.key) {
+            return { error: `${entry.relPath}: fetched key ${restoredKey} != ${entry.key}`, filePath: entry.filePath };
+        }
+        return {
+            content: restored,
+            filePath: entry.filePath,
+            id: entry.id,
+            relPath: entry.relPath,
+        };
+    });
+    const results = [];
+    for (const item of fetched) {
+        if ('error' in item) {
+            return { ok: false, reason: item.error ?? 'unknown fetch error' };
+        }
+        results.push(item);
+    }
+    for (const entry of resolved) {
+        ids[entry.relPath] = {
+            id: entry.id,
+            key: entry.key,
+            sha256: '',
+        };
+    }
+    return { ids, ok: true, results };
+}

package/dist/utils/reference-checker.d.ts

@@ -42,6 +42,9 @@ export declare function checkReferences(documents: Array<{
 }>, serverOperations?: Array<{
     name: string;
     type: string;
+}>, scanDocuments?: Array<{
+    content: string;
+    filePath: string;
 }>): BadReference[];
 export interface BadIndex {
     field: string;

package/dist/utils/reference-checker.js

@@ -107,7 +107,7 @@ export function buildServerRegistry(operations) {
  * both local files AND server-known objects, eliminating false positives for objects
  * that exist on the server but aren't in the push set.
  */
-export function checkReferences(documents, serverOperations) {
+export function checkReferences(documents, serverOperations, scanDocuments) {
     const registry = buildRegistry(documents);
     // Merge server-known names into the registry
     if (serverOperations) {
@@ -122,7 +122,8 @@ export function checkReferences(documents, serverOperations) {
         }
     }
     const badRefs = [];
-    for (const doc of documents) {
+    const toScan = scanDocuments ?? documents;
+    for (const doc of toScan) {
         const parsed = parseDocument(doc.content);
         if (!parsed)
             continue;

package/dist/utils/sandbox-marker.d.ts

@@ -0,0 +1,9 @@
+export declare const SANDBOX_MARKER_VERSION = 1;
+export declare const SANDBOX_MARKER_FILENAME = "sandbox_sync.json";
+export declare function sandboxMarkerPath(dir: string): string;
+export declare function sandboxMarkerExists(dir: string): boolean;
+export declare function sandboxMarkerKey(host: string, tenantId: number | string): string;
+export declare function readMarkerToken(dir: string, host: string, tenantId: number | string): null | string;
+export declare function writeMarkerToken(dir: string, host: string, tenantId: number | string): string;
+export declare function invalidateMarkerHost(dir: string, host: string): void;
+export declare function invalidateSandboxMarkerForOrigin(dir: string, instanceOrigin: string): void;

package/dist/utils/sandbox-marker.js

@@ -0,0 +1,119 @@
+import { randomUUID } from 'node:crypto';
+import * as fs from 'node:fs';
+import { join } from 'node:path';
+import { instanceHost } from './sync-state.js';
+export const SANDBOX_MARKER_VERSION = 1;
+export const SANDBOX_MARKER_FILENAME = 'sandbox_sync.json';
+const TEMP_PREFIX = `${SANDBOX_MARKER_FILENAME}.tmp-`;
+export function sandboxMarkerPath(dir) {
+    return join(dir, SANDBOX_MARKER_FILENAME);
+}
+export function sandboxMarkerExists(dir) {
+    return fs.existsSync(sandboxMarkerPath(dir));
+}
+export function sandboxMarkerKey(host, tenantId) {
+    return `${host}#${tenantId}`;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function parseMarkerFile(raw) {
+    if (!isRecord(raw))
+        return null;
+    if (raw.version !== SANDBOX_MARKER_VERSION)
+        return null;
+    if (!isRecord(raw.sandboxes))
+        return null;
+    const sandboxes = {};
+    for (const [key, value] of Object.entries(raw.sandboxes)) {
+        if (!isRecord(value) || typeof value.token !== 'string' || value.token.length === 0) {
+            return null;
+        }
+        sandboxes[key] = { token: value.token };
+    }
+    return { sandboxes, version: SANDBOX_MARKER_VERSION };
+}
+function readMarkerFile(dir) {
+    const filePath = sandboxMarkerPath(dir);
+    if (!fs.existsSync(filePath))
+        return null;
+    try {
+        return parseMarkerFile(JSON.parse(fs.readFileSync(filePath, 'utf8')));
+    }
+    catch {
+        return null;
+    }
+}
+function cleanupTempFiles(dir, keep) {
+    let names = [];
+    try {
+        names = fs.readdirSync(dir);
+    }
+    catch {
+        return;
+    }
+    for (const name of names) {
+        if (!name.startsWith(TEMP_PREFIX))
+            continue;
+        const full = join(dir, name);
+        if (keep && full === keep)
+            continue;
+        try {
+            fs.unlinkSync(full);
+        }
+        catch {
+            // Best-effort cleanup.
+        }
+    }
+}
+function atomicWrite(dir, payload) {
+    fs.mkdirSync(dir, { recursive: true });
+    const dest = sandboxMarkerPath(dir);
+    const tmp = join(dir, `${TEMP_PREFIX}${process.pid}`);
+    try {
+        fs.writeFileSync(tmp, `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
+        fs.renameSync(tmp, dest);
+    }
+    catch (error) {
+        try {
+            fs.unlinkSync(tmp);
+        }
+        catch {
+            // Already gone.
+        }
+        throw error;
+    }
+    finally {
+        cleanupTempFiles(dir);
+    }
+}
+export function readMarkerToken(dir, host, tenantId) {
+    const file = readMarkerFile(dir);
+    if (!file)
+        return null;
+    return file.sandboxes[sandboxMarkerKey(host, tenantId)]?.token ?? null;
+}
+export function writeMarkerToken(dir, host, tenantId) {
+    const token = randomUUID();
+    const existing = readMarkerFile(dir);
+    const sandboxes = existing?.sandboxes ? { ...existing.sandboxes } : {};
+    sandboxes[sandboxMarkerKey(host, tenantId)] = { token };
+    atomicWrite(dir, { sandboxes, version: SANDBOX_MARKER_VERSION });
+    return token;
+}
+export function invalidateMarkerHost(dir, host) {
+    const file = readMarkerFile(dir);
+    if (!file)
+        return;
+    const prefix = `${host}#`;
+    const sandboxes = {};
+    for (const [key, entry] of Object.entries(file.sandboxes)) {
+        if (!key.startsWith(prefix)) {
+            sandboxes[key] = entry;
+        }
+    }
+    atomicWrite(dir, { sandboxes, version: SANDBOX_MARKER_VERSION });
+}
+export function invalidateSandboxMarkerForOrigin(dir, instanceOrigin) {
+    invalidateMarkerHost(dir, instanceHost(instanceOrigin));
+}

package/dist/utils/sync-state.d.ts

@@ -0,0 +1,71 @@
+export declare const SYNC_STATE_VERSION = 1;
+export declare const SYNC_STATE_DIR = ".xano";
+export declare const SYNC_STATE_FILENAME = "sync_state.json";
+export interface SyncFileEntry {
+    id?: number;
+    key: string;
+    sha256: string;
+}
+export interface SyncTargetIdentity {
+    branch: string;
+    branch_created_at: string;
+    instance_host: string;
+    workspace_created_at: string;
+    workspace_id: string;
+}
+export interface SyncTargetState extends SyncTargetIdentity {
+    files: Record<string, SyncFileEntry>;
+    sandbox_token?: string;
+}
+export interface SyncStateFile {
+    targets: SyncTargetState[];
+    version: number;
+}
+export interface LocalFileHash {
+    relPath: string;
+    sha256: string;
+}
+export interface CandidateResult {
+    candidates: LocalFileHash[];
+    deletedLocally: Array<{
+        key: string;
+        relPath: string;
+    }>;
+    unchanged: LocalFileHash[];
+}
+export type MetaGet = (pathname: string) => Promise<unknown>;
+export declare function instanceHost(instanceOrigin: string): string;
+export declare function toRelPath(dir: string, filePath: string): string;
+export declare function hashBytes(data: Buffer | string): string;
+export declare function hashFile(filePath: string): string;
+export declare function syncStatePath(dir: string): string;
+export declare function syncStateExists(dir: string): boolean;
+export declare function recordEntriesForPaths(dir: string, filePaths: string[]): Record<string, SyncFileEntry>;
+/**
+ * Build record entries from file bytes the caller already holds. Push uses this to record
+ * exactly what it sent, so an edit made while the push ran is not recorded as synced.
+ */
+export declare function recordEntriesForContents(dir: string, files: Array<{
+    content: string;
+    filePath: string;
+}>): Record<string, SyncFileEntry>;
+export declare function sandboxTargetIdentity(host: string, tenant: {
+    created_at: string;
+    id: number;
+}): SyncTargetIdentity;
+export declare function sameTargetIdentity(a: SyncTargetIdentity, b: SyncTargetIdentity): boolean;
+export declare function sameTargetFingerprints(a: SyncTargetIdentity, b: SyncTargetIdentity): boolean;
+export declare function readSyncStateFile(dir: string, warn?: (message: string) => void): null | SyncStateFile;
+export declare function loadSyncState(dir: string, target: SyncTargetIdentity, warn?: (message: string) => void): null | SyncTargetState;
+export interface ResolvedTarget extends SyncTargetIdentity {
+    live_branch: string;
+}
+export declare function resolveTarget(instanceOrigin: string, workspaceId: string, branch: string, fetchJson: MetaGet): Promise<null | ResolvedTarget>;
+export declare function computeCandidates(files: LocalFileHash[], state: null | SyncTargetState): CandidateResult;
+export declare function recordFiles(state: SyncTargetState, entries: Record<string, SyncFileEntry>): SyncTargetState;
+export declare function saveSyncState(dir: string, target: SyncTargetIdentity, entries: Record<string, SyncFileEntry>, options?: {
+    pruneMissing?: boolean;
+    replace?: boolean;
+    sandboxToken?: string;
+}): void;
+export declare function listSyncDir(dir: string): string[];