@tiangong-ai/cli 0.0.50 → 0.0.55

package/dist/data/contracts.d.ts

@@ -0,0 +1,374 @@
+export declare const DATA_MANIFEST_SCHEMA_VERSION: "tiangong.data.manifest.v1";
+export declare const DATA_DISCOVERY_SCHEMA_VERSION: "tiangong.data.discovery.v1";
+export declare const DATA_CATALOG_SCHEMA_VERSION: "tiangong.data.catalog.v1";
+export declare const DATA_DESCRIBE_SCHEMA_VERSION: "tiangong.data.describe.v1";
+export declare const DATA_DOCTOR_SCHEMA_VERSION: "tiangong.data.doctor.v1";
+export declare const DATA_RUN_REQUEST_SCHEMA_VERSION: "tiangong.data.run-request.v1";
+export declare const DATA_RUN_RESULT_SCHEMA_VERSION: "tiangong.data.run-result.v1";
+export declare const DATA_ERROR_SCHEMA_VERSION: "tiangong.data.error.v1";
+export declare const DATA_RECEIPT_SCHEMA_VERSION: "tiangong.data.core-receipt.v1";
+export type JsonPrimitive = boolean | null | number | string;
+export type JsonValue = JsonPrimitive | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export type JsonSchema = Record<string, unknown>;
+export type DataErrorCode = "invalid-request" | "unsupported-operation" | "incompatible-contract" | "credential-missing" | "credential-invalid" | "provider-auth-blocked" | "endpoint-policy-blocked" | "rate-limited" | "timeout" | "network-failed" | "response-too-large" | "provider-response-invalid" | "normalization-failed" | "partial-result" | "internal-error";
+export interface DataMachineError {
+    code: DataErrorCode;
+    message: string;
+    retryable: boolean;
+    userActionRequired: boolean;
+    details?: Record<string, JsonValue> | undefined;
+}
+export interface DataErrorEnvelope {
+    schemaVersion: typeof DATA_ERROR_SCHEMA_VERSION;
+    status: "blocked";
+    errors: DataMachineError[];
+}
+export interface DataExecutionLimits {
+    timeoutMs: number;
+    maxRequestBytes: number;
+    maxResponseBytes: number;
+    maxPages: number;
+    maxRecords: number;
+    maxRetries: number;
+    maxRetryDelayMs: number;
+    maxRedirects: number;
+}
+export interface DataLimitOverrides {
+    timeoutMs?: number | undefined;
+    maxResponseBytes?: number | undefined;
+    maxPages?: number | undefined;
+    maxRecords?: number | undefined;
+}
+export interface DataEndpointScope {
+    endpointId: string;
+    baseUrl: string;
+    pathPrefixes: string[];
+    allowedMethods: Array<"GET" | "POST">;
+    allowedContentTypes: string[];
+}
+export interface DataCredentialDeclaration {
+    credentialId: string;
+    environmentVariable: string;
+    required: boolean;
+    endpointIds: string[];
+    injection: {
+        kind: "header";
+        name: string;
+        prefix: string;
+    } | {
+        kind: "path-segment";
+        placeholder: `{${string}}`;
+    };
+}
+export interface DataSchemaReference {
+    schemaId: string;
+    digest: string;
+}
+export interface DataOperationManifest {
+    operationId: string;
+    operationVersion: string;
+    inputSchema: DataSchemaReference;
+    outputSchema: DataSchemaReference;
+    limits: DataExecutionLimits;
+    artifactOutput?: DataArtifactOutputDeclaration | undefined;
+}
+export interface DataArtifactOutputDeclaration {
+    kind: "directory";
+    required: true;
+}
+export interface DataArtifactRecord {
+    relativePath: string;
+    sha256: string;
+    byteSize: number;
+}
+export interface DataArtifactSink {
+    assertAvailable(relativePath: string): Promise<void>;
+    stage(relativePath: string, bytes: Uint8Array): Promise<DataArtifactRecord>;
+}
+/** The capability's execution contract. Discovery prose is intentionally excluded. */
+export interface DataCapabilityManifest {
+    schemaVersion: typeof DATA_MANIFEST_SCHEMA_VERSION;
+    capabilityId: string;
+    capabilityVersion: string;
+    minimumCliVersion: string;
+    providerId: string;
+    endpoints: DataEndpointScope[];
+    credentials: DataCredentialDeclaration[];
+    limits: DataExecutionLimits;
+    diagnostics: {
+        static: true;
+        live: boolean;
+    };
+    operations: DataOperationManifest[];
+    manifestDigest: string;
+}
+export interface DataSourceDocumentation {
+    title: string;
+    url: string;
+}
+export interface DataCapabilityDiscovery {
+    schemaVersion: typeof DATA_DISCOVERY_SCHEMA_VERSION;
+    capabilityId: string;
+    capabilityVersion: string;
+    source: {
+        providerId: string;
+        name: string;
+        maintainedBy: string;
+        sourceCategory: string;
+        summary: string;
+        description: string;
+        coverage: {
+            geographic: string;
+            temporal: string;
+            granularity: string;
+        };
+    };
+    summary: string;
+    description: string;
+    provides: string[];
+    doesNotProvide: string[];
+    selectionHints: string[];
+    typicalUseCases: string[];
+    sourceDocumentation: DataSourceDocumentation[];
+    license: {
+        name: string;
+        url: string;
+        restrictions: string[];
+    };
+    freshness: {
+        kind: string;
+        description: string;
+    };
+    limitations: string[];
+    operations: Array<{
+        operationId: string;
+        summary: string;
+        description: string;
+    }>;
+    discoveryDigest: string;
+}
+export interface DataCatalogCapability {
+    capabilityId: string;
+    capabilityVersion: string;
+    minimumCliVersion: string;
+    providerId: string;
+    sourceCategory: string;
+    summary: string;
+    provides: string[];
+    doesNotProvide: string[];
+    manifestDigest: string;
+    discoveryDigest: string;
+    operations: Array<{
+        operationId: string;
+        operationVersion: string;
+        summary: string;
+        inputSchemaDigest: string;
+        outputSchemaDigest: string;
+    }>;
+}
+export interface DataCatalogResult {
+    schemaVersion: typeof DATA_CATALOG_SCHEMA_VERSION;
+    capabilities: DataCatalogCapability[];
+    catalogDigest: string;
+}
+export interface DataDescribeResult {
+    schemaVersion: typeof DATA_DESCRIBE_SCHEMA_VERSION;
+    manifest: DataCapabilityManifest;
+    discovery: DataCapabilityDiscovery;
+    schemas: Record<string, JsonSchema>;
+}
+export interface DataDoctorCheck {
+    checkId: string;
+    status: "pass" | "warn" | "fail";
+    message: string;
+    details?: Record<string, JsonValue> | undefined;
+}
+export interface DataDoctorResult {
+    schemaVersion: typeof DATA_DOCTOR_SCHEMA_VERSION;
+    capabilityId: string;
+    capabilityVersion: string;
+    manifestDigest: string;
+    mode: "static" | "live";
+    status: "ready" | "degraded" | "blocked";
+    networkAttempted: boolean;
+    checks: DataDoctorCheck[];
+}
+export interface DataRunRequest {
+    schemaVersion: typeof DATA_RUN_REQUEST_SCHEMA_VERSION;
+    capabilityId: string;
+    capabilityVersion: string;
+    operationId: string;
+    operationVersion: string;
+    input: unknown;
+    limits?: DataLimitOverrides | undefined;
+    requestId?: string | undefined;
+}
+export interface DataMissingRange {
+    kind: "chunk" | "field" | "file" | "page" | "range";
+    identifiers: string[];
+}
+export interface DataExecutionSummary {
+    recordCount: number;
+    pageCount: number;
+    chunkCount: number;
+    truncated: boolean;
+    completeness: "complete" | "partial" | "blocked";
+    missing?: DataMissingRange[] | undefined;
+}
+export interface DataSourceObservation {
+    observationId: string;
+    sourceId: string;
+    endpointId: string;
+    requestDigest: string;
+    responseDigest: string;
+    responseBytes: number;
+    status: number;
+    contentType: string;
+    attempts: number;
+}
+export interface CoreDataReceipt {
+    schemaVersion: typeof DATA_RECEIPT_SCHEMA_VERSION;
+    cliVersion: string;
+    capabilityId: string;
+    capabilityVersion: string;
+    operationId: string;
+    operationVersion: string;
+    requestDigest: string;
+    manifestDigest: string | null;
+    inputSchemaDigest: string | null;
+    outputSchemaDigest: string | null;
+    inputDigest: string;
+    aggregateResponseDigest: string | null;
+    normalizedDataDigest: string | null;
+    observations: DataSourceObservation[];
+    completionStatus: "success" | "partial" | "blocked";
+    summary: DataExecutionSummary;
+    generatedAt: string;
+    receiptDigest: string;
+}
+export interface DataRunResult {
+    schemaVersion: typeof DATA_RUN_RESULT_SCHEMA_VERSION;
+    status: "success" | "partial" | "blocked";
+    requestId: string | null;
+    contract: {
+        cliVersion: string;
+        capabilityId: string;
+        capabilityVersion: string;
+        operationId: string;
+        operationVersion: string;
+        manifestDigest: string | null;
+        inputSchema: DataSchemaReference | null;
+        outputSchema: DataSchemaReference | null;
+    };
+    data: unknown | null;
+    summary: DataExecutionSummary;
+    warnings: string[];
+    errors: DataMachineError[];
+    receipt: CoreDataReceipt;
+}
+export interface DataHttpRequest {
+    endpointId: string;
+    method: "GET" | "POST";
+    path: string;
+    query?: Record<string, boolean | number | string | Array<boolean | number | string>> | undefined;
+    body?: JsonValue | undefined;
+    credentialId?: string | undefined;
+    timeoutMs?: number | undefined;
+    maxResponseBytes?: number | undefined;
+}
+export interface DataHttpResponse {
+    bytes: Uint8Array;
+    safeHeaders: Record<string, string>;
+    observation: DataSourceObservation;
+    json(): unknown;
+    text(): string;
+}
+export interface DataHttpClient {
+    request(request: DataHttpRequest): Promise<DataHttpResponse>;
+    configuredSecrets(): string[];
+}
+export interface DataOperationExecutionContext {
+    input: unknown;
+    request: DataRunRequest;
+    limits: DataExecutionLimits;
+    http: DataHttpClient;
+    artifacts: DataArtifactSink | null;
+}
+export interface DataOperationExecution {
+    status: "success" | "partial";
+    data: unknown;
+    summary: DataExecutionSummary;
+    warnings: string[];
+    errors: DataMachineError[];
+    observations: DataSourceObservation[];
+}
+export interface DataOperationDefinition {
+    operationId: string;
+    operationVersion: string;
+    summary: string;
+    description: string;
+    inputSchema: JsonSchema;
+    outputSchema: JsonSchema;
+    limits?: Partial<DataExecutionLimits> | undefined;
+    artifactOutput?: DataArtifactOutputDeclaration | undefined;
+    execute(context: DataOperationExecutionContext): DataOperationExecution | Promise<DataOperationExecution>;
+}
+export interface DataLiveDoctorContext {
+    http: DataHttpClient;
+}
+export interface DataLiveDoctorExecution {
+    status: "ready" | "degraded" | "blocked";
+    checks: DataDoctorCheck[];
+    networkAttempted?: boolean | undefined;
+}
+export interface DataConnectorDefinition {
+    schemaVersion: typeof DATA_MANIFEST_SCHEMA_VERSION;
+    capabilityId: string;
+    capabilityVersion: string;
+    minimumCliVersion: string;
+    provider: {
+        providerId: string;
+        name: string;
+    };
+    sourceCategory: string;
+    endpoints: DataEndpointScope[];
+    license: {
+        name: string;
+        url: string;
+        restrictions: string[];
+    };
+    credentials: DataCredentialDeclaration[];
+    limits: DataExecutionLimits;
+    diagnostics: {
+        static: true;
+        live: boolean;
+    };
+    freshness: {
+        kind: string;
+        description: string;
+    };
+    limitations: string[];
+    discovery: {
+        source: {
+            maintainedBy: string;
+            summary: string;
+            description: string;
+            coverage: {
+                geographic: string;
+                temporal: string;
+                granularity: string;
+            };
+        };
+        summary: string;
+        description: string;
+        provides: string[];
+        doesNotProvide: string[];
+        selectionHints: string[];
+        typicalUseCases: string[];
+        sourceDocumentation: DataSourceDocumentation[];
+    };
+    operations: DataOperationDefinition[];
+    liveDoctor?: ((context: DataLiveDoctorContext) => DataLiveDoctorExecution | Promise<DataLiveDoctorExecution>) | undefined;
+}

package/dist/data/contracts.js

@@ -0,0 +1,10 @@
+export const DATA_MANIFEST_SCHEMA_VERSION = "tiangong.data.manifest.v1";
+export const DATA_DISCOVERY_SCHEMA_VERSION = "tiangong.data.discovery.v1";
+export const DATA_CATALOG_SCHEMA_VERSION = "tiangong.data.catalog.v1";
+export const DATA_DESCRIBE_SCHEMA_VERSION = "tiangong.data.describe.v1";
+export const DATA_DOCTOR_SCHEMA_VERSION = "tiangong.data.doctor.v1";
+export const DATA_RUN_REQUEST_SCHEMA_VERSION = "tiangong.data.run-request.v1";
+export const DATA_RUN_RESULT_SCHEMA_VERSION = "tiangong.data.run-result.v1";
+export const DATA_ERROR_SCHEMA_VERSION = "tiangong.data.error.v1";
+export const DATA_RECEIPT_SCHEMA_VERSION = "tiangong.data.core-receipt.v1";
+//# sourceMappingURL=contracts.js.map

package/dist/data/contracts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"contracts.js","sourceRoot":"","sources":["../../src/data/contracts.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,4BAA4B,GAAG,2BAAoC,CAAC;AACjF,MAAM,CAAC,MAAM,6BAA6B,GAAG,4BAAqC,CAAC;AACnF,MAAM,CAAC,MAAM,2BAA2B,GAAG,0BAAmC,CAAC;AAC/E,MAAM,CAAC,MAAM,4BAA4B,GAAG,2BAAoC,CAAC;AACjF,MAAM,CAAC,MAAM,0BAA0B,GAAG,yBAAkC,CAAC;AAC7E,MAAM,CAAC,MAAM,+BAA+B,GAAG,8BAAuC,CAAC;AACvF,MAAM,CAAC,MAAM,8BAA8B,GAAG,6BAAsC,CAAC;AACrF,MAAM,CAAC,MAAM,yBAAyB,GAAG,wBAAiC,CAAC;AAC3E,MAAM,CAAC,MAAM,2BAA2B,GAAG,+BAAwC,CAAC"}

package/dist/data/runtime/artifacts.d.ts

@@ -0,0 +1,6 @@
+import type { DataArtifactSink } from "../contracts.js";
+export interface DataArtifactSession extends DataArtifactSink {
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+}
+export declare function createDataArtifactSession(directory: string): Promise<DataArtifactSession>;

package/dist/data/runtime/artifacts.js

@@ -0,0 +1,103 @@
+import { randomUUID } from "node:crypto";
+import { link, lstat, realpath, unlink, writeFile } from "node:fs/promises";
+import { isAbsolute, join } from "node:path";
+import { sha256Bytes } from "./canonical-json.js";
+import { DataRuntimeError } from "./errors.js";
+const SAFE_ARTIFACT_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]{0,239}$/;
+export async function createDataArtifactSession(directory) {
+    if (!isAbsolute(directory)) {
+        throw new DataRuntimeError("invalid-request", "The artifact output directory must be an absolute path.");
+    }
+    let root;
+    try {
+        const metadata = await lstat(directory);
+        if (!metadata.isDirectory() || metadata.isSymbolicLink())
+            throw new Error("not-directory");
+        root = await realpath(directory);
+    }
+    catch {
+        throw new DataRuntimeError("invalid-request", "The artifact output directory must be an existing non-symbolic-link directory.");
+    }
+    const staged = new Map();
+    let settled = false;
+    const assertAvailable = async (relativePath) => {
+        assertArtifactName(relativePath);
+        if (settled)
+            throw new DataRuntimeError("internal-error", "The artifact session is closed.");
+        if (staged.has(relativePath) || (await pathExists(join(root, relativePath)))) {
+            throw new DataRuntimeError("invalid-request", "The artifact output directory already contains a requested output file.", { details: { relativePath } });
+        }
+    };
+    return {
+        assertAvailable,
+        stage: async (relativePath, bytes) => {
+            await assertAvailable(relativePath);
+            const temporaryPath = join(root, `.tiangong-${randomUUID()}.tmp`);
+            try {
+                await writeFile(temporaryPath, bytes, { flag: "wx", mode: 0o600 });
+            }
+            catch {
+                await unlink(temporaryPath).catch(() => undefined);
+                throw new DataRuntimeError("internal-error", "The artifact could not be staged safely.");
+            }
+            const record = {
+                relativePath,
+                sha256: sha256Bytes(bytes),
+                byteSize: bytes.byteLength,
+                temporaryPath,
+                finalPath: join(root, relativePath),
+            };
+            staged.set(relativePath, record);
+            return publicRecord(record);
+        },
+        commit: async () => {
+            if (settled)
+                throw new DataRuntimeError("internal-error", "The artifact session is closed.");
+            const committed = [];
+            try {
+                for (const artifact of staged.values()) {
+                    await link(artifact.temporaryPath, artifact.finalPath);
+                    committed.push(artifact);
+                }
+            }
+            catch (error) {
+                await Promise.allSettled(committed.map((artifact) => unlink(artifact.finalPath)));
+                throw new DataRuntimeError("invalid-request", "The artifact outputs could not be committed without overwriting existing files.", { details: { reason: error instanceof Error ? error.name : "unknown" } });
+            }
+            finally {
+                await Promise.allSettled([...staged.values()].map((artifact) => unlink(artifact.temporaryPath)));
+                settled = true;
+            }
+        },
+        rollback: async () => {
+            if (settled)
+                return;
+            await Promise.allSettled([...staged.values()].map((artifact) => unlink(artifact.temporaryPath)));
+            settled = true;
+        },
+    };
+}
+function assertArtifactName(relativePath) {
+    if (!SAFE_ARTIFACT_NAME.test(relativePath)) {
+        throw new DataRuntimeError("invalid-request", "Artifact filenames must be safe single-segment relative names.");
+    }
+}
+async function pathExists(path) {
+    try {
+        await lstat(path);
+        return true;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return false;
+        throw new DataRuntimeError("internal-error", "Artifact output availability could not be checked.");
+    }
+}
+function publicRecord(record) {
+    return {
+        relativePath: record.relativePath,
+        sha256: record.sha256,
+        byteSize: record.byteSize,
+    };
+}
+//# sourceMappingURL=artifacts.js.map

package/dist/data/runtime/artifacts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"artifacts.js","sourceRoot":"","sources":["../../../src/data/runtime/artifacts.ts"],"names":[],"mappings":"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"}

package/dist/data/runtime/bounded-http.d.ts

@@ -0,0 +1,10 @@
+import type { DataCredentialDeclaration, DataEndpointScope, DataExecutionLimits, DataHttpClient } from "../contracts.js";
+export interface BoundedHttpClientOptions {
+    capabilityId: string;
+    endpoints: readonly DataEndpointScope[];
+    credentials: readonly DataCredentialDeclaration[];
+    environment: NodeJS.ProcessEnv;
+    limits: DataExecutionLimits;
+    fetchImpl?: typeof fetch | undefined;
+}
+export declare function createBoundedHttpClient(options: BoundedHttpClientOptions): DataHttpClient;