dataiku-sdk 3.7.0 → 3.9.0

package/dist/src/cli/commands/wiki.js

@@ -1,3 +1,4 @@
+import { findWikiAttachment, statWikiAttachmentFile, wikiAttachmentNotFound, wikiAttachments, } from "../../resources/wiki.js";
 import { deepMerge, } from "../../utils/deep-merge.js";
 import { jsonInput, textInput, } from "../coerce.js";
 import { executionMode, } from "../flags.js";
@@ -117,6 +118,61 @@ export const wikiCommands = withUsage("wiki", {
         description: "Delete a wiki article.",
         examples: ["dss wiki delete ARTICLE_ID --dry-run",],
     },
+    attach: {
+        handler: async (c, a, f) => {
+            requireArgs(a, 2, commandUsage("wiki", "attach"));
+            const pk = f["project-key"];
+            const file = await statWikiAttachmentFile(a[1]);
+            if (executionMode(f).dryRun) {
+                const current = await c.wiki.get(a[0], pk);
+                return {
+                    dryRun: true,
+                    action: "attach",
+                    resource: "wiki",
+                    article: a[0],
+                    file,
+                    current: wikiAttachments(current),
+                };
+            }
+            const result = await c.wiki.attach(a[0], a[1], pk);
+            return { attached: result.attachment.smartId, resource: "wiki", ...result, };
+        },
+        description: "Upload a local file and attach it to a wiki article; returns its smartId.",
+        examples: ["dss wiki attach ARTICLE_ID ./diagram.png --dry-run",],
+    },
+    detach: {
+        handler: async (c, a, f) => {
+            requireArgs(a, 2, commandUsage("wiki", "detach"));
+            const pk = f["project-key"];
+            const ifExists = f["if-exists"] === true;
+            const dryRun = executionMode(f).dryRun;
+            if (dryRun || ifExists) {
+                const current = ifExists
+                    ? await readIfExists(() => c.wiki.get(a[0], pk))
+                    : await c.wiki.get(a[0], pk);
+                const attachment = current && findWikiAttachment(current, a[1]);
+                if (!current || !attachment) {
+                    if (!ifExists && current)
+                        throw wikiAttachmentNotFound(current, a[1]);
+                    return skipResult("wiki", a[1], "missing", { article: a[0], });
+                }
+                if (dryRun) {
+                    return {
+                        dryRun: true,
+                        action: "detach",
+                        resource: "wiki",
+                        article: a[0],
+                        smartId: a[1],
+                        current: attachment,
+                    };
+                }
+            }
+            const result = await c.wiki.detach(a[0], a[1], pk);
+            return { resource: "wiki", ...result, };
+        },
+        description: "Remove one attachment from a wiki article by smartId.",
+        examples: ["dss wiki detach ARTICLE_ID SMART_ID --if-exists",],
+    },
     "update-settings": {
         handler: async (c, _a, f) => {
             const pk = f["project-key"];

package/dist/src/cli/contract.js

@@ -411,6 +411,8 @@ function payloadJsonSchema(payloadSchema) {
     if (payloadSchema.contentType === "text/plain") {
         return { type: "string", contentMediaType: "text/plain", };
     }
+    if (payloadSchema.jsonSchema)
+        return payloadSchema.jsonSchema;
     return payloadSchema.jsonShape === "array"
         ? { type: "array", items: true, }
         : { type: "object", additionalProperties: true, };
@@ -722,7 +724,7 @@ function inferSideEffect(resource, action) {
     }
     if (READ_ACTIONS.has(action))
         return "read";
-    if (/^(create|clone|restore|update|delete|set|save|upload|run|build|abort|move|refresh|clear|unload|install|login|logout|add|remove|publish|activate|deploy|import|export|preload|upgrade|start|stop|restart|duplicate|put|rename|reply|compute|organize)/
+    if (/^(create|clone|restore|update|delete|set|save|upload|run|build|abort|move|refresh|clear|unload|install|login|logout|add|remove|publish|activate|deploy|import|export|preload|upgrade|start|stop|restart|duplicate|put|rename|reply|compute|organize|attach|detach)/
         .test(action)
         // Compound actions whose mutating verb is a suffix (e.g. permissions-set,
         // dataset-compute, saved-model external-metadata-put).
@@ -876,6 +878,8 @@ export function supportsCleanupLedger(resource, action) {
 const EXPLICIT_DESTRUCTIVE_KEYS = {
     "dataset.upload-file": true,
     "sql.query": true,
+    // Detaching drops the attachment from the article; no public route restores it.
+    "wiki.detach": true,
     // Plugin dev-Git and content deletions discard work with no undo route.
     "plugin.delete": true,
     "plugin.delete-git-remote": true,
@@ -961,8 +965,10 @@ function inferIdempotency(resource, sideEffect, action, syntax) {
     if (action.startsWith("create") && syntaxHasFlag(syntax, "if-not-exists")) {
         return "if-not-exists";
     }
-    if (action.startsWith("delete") && syntaxHasFlag(syntax, "if-exists"))
+    if ((action.startsWith("delete") || `${resource}.${action}` === "wiki.detach")
+        && syntaxHasFlag(syntax, "if-exists")) {
         return "if-exists";
+    }
     if (`${resource}.${action}` === "app.set-manifest-version")
         return "none";
     // `app delete-instance` converges without an `--if-exists` flag: an absent
@@ -1062,6 +1068,8 @@ export function buildRegistryEntry(resource, action, meta) {
     const payloadSchema = meta.payloadSchema
         ?? EXPLICIT_REGISTRY_OVERRIDES[registryKey(resource, action)]?.payloadSchema
         ?? inferPayloadSchema(inputContract);
+    // The precise JSON Schema is published once, as `schemas.input`.
+    const { jsonSchema: _jsonSchema, ...payloadSummary } = payloadSchema ?? {};
     const examplePayload = meta.examplePayload
         ?? EXPLICIT_REGISTRY_OVERRIDES[registryKey(resource, action)]?.examplePayload;
     const inferredCleanupCommand = meta.cleanupCommand
@@ -1126,7 +1134,7 @@ export function buildRegistryEntry(resource, action, meta) {
         optionalFlags: uniqueOptionalFlags,
         ...(requiredOneOf.length > 0 ? { requiredOneOf, } : {}),
         ...(inputGroups.length > 0 ? { requiredInputGroups: inputGroups, } : {}),
-        ...(payloadSchema ? { payloadSchema, } : {}),
+        ...(payloadSchema ? { payloadSchema: payloadSummary, } : {}),
         get schemas() {
             return schemas ??= buildCommandSchemas(resource, action, flagMetadata, uniqueRequiredFlags, requiredOneOf, payloadSchema, outputShape, meta.usage);
         },
@@ -1392,11 +1400,10 @@ function commandRegistryJsonSchema() {
 function errorEnvelopeJsonSchema() {
     return {
         type: "object",
-        required: ["type", "ok", "error", "code", "category", "exitCode",],
+        required: ["type", "error", "code", "category", "exitCode",],
         additionalProperties: true,
         properties: {
             type: { const: "error", },
-            ok: { const: false, },
             error: { type: "string", },
             code: { type: "string", },
             category: { enum: ["usage", "permission_or_environment", "dss", "internal",], },
@@ -1406,8 +1413,6 @@ function errorEnvelopeJsonSchema() {
             retryable: { type: "boolean", },
             requestId: { type: "string", },
             details: { type: "object", additionalProperties: true, },
-            resource: { type: "string", },
-            action: { type: "string", },
             projectKey: { type: "string", },
         },
     };
@@ -1518,7 +1523,7 @@ export function buildAgentContract() {
                 failure: "structured-error-object",
                 failureResultDetailLimitBytes: 65_536,
                 fieldProjection: "Missing --fields paths: null on stdout; field_projection_missing on stderr.",
-                lists: "*.list: compact items; --full/--fields use DSS objects; --contains/--limit filter (list_truncated warning).",
+                compactResults: "*.list, job get, dataset get/info, project get: compact; --full/--fields use DSS objects; lists take --contains/--limit (list_truncated warning).",
                 richFailureResults: "doctor/batch/cleanup failures: own compact {ok:false,...} result on stdout and command exit code; no wrapper.",
             },
             stderr: {

package/dist/src/cli/doctor.js

@@ -11,6 +11,8 @@ export function errorDetails(error) {
             retryable: error.retryable,
             status: error.status,
             statusText: error.statusText,
+            message: error.message,
+            retryHint: error.retryHint,
         };
     }
     return { message: error instanceof Error ? error.message : String(error), };

package/dist/src/cli/flags.d.ts

@@ -18,6 +18,13 @@ export declare const REPEATABLE_VALUE_FLAGS: Set<string>;
 export declare const KNOWN_LONG_FLAGS: Set<string>;
 export declare function normalizeLongFlag(rawFlagName: string, argv: string[]): string;
 export declare function isNegativeNumberToken(value: string): boolean;
+/**
+ * Whether the token after a value flag is that flag's value rather than the
+ * next flag. `-` (stdin), negative numbers, and anything not flag-shaped
+ * qualify, so a SQL value beginning with a `-- comment` is a value; `--` alone
+ * and `--flag`/`--flag=x` are not.
+ */
+export declare function isFlagValueToken(token: string): boolean;
 export declare function requireFlagValue(flagLabel: string, next: string | undefined): string;
 export declare function setParsedFlagValue(flags: Record<string, string | boolean>, flagName: string, value: string): void;
 export interface ParsedArgs {

package/dist/src/cli/flags.js

@@ -81,6 +81,7 @@ export const BOOLEAN_FLAGS = new Set([
     "allow-same-path",
     "sync",
     "validate-objects",
+    "recreate-on-move",
     "errors-only",
     "keep",
     "full-log",
@@ -223,6 +224,8 @@ export const VALUE_FLAGS = new Set([
     "render",
     "prediction-type",
     "project-key",
+    "query",
+    "query-file",
     "recipe",
     "reference",
     "repository",
@@ -353,9 +356,32 @@ export function normalizeLongFlag(rawFlagName, argv) {
 export function isNegativeNumberToken(value) {
     return value.startsWith("-") && Number.isFinite(Number(value));
 }
+/** `--name` or `--name=value`: a token that parses as a long flag. */
+const LONG_FLAG_SHAPE = /^--[A-Za-z][A-Za-z0-9-]*(?:=|$)/;
+/**
+ * Whether the token after a value flag is that flag's value rather than the
+ * next flag. `-` (stdin), negative numbers, and anything not flag-shaped
+ * qualify, so a SQL value beginning with a `-- comment` is a value; `--` alone
+ * and `--flag`/`--flag=x` are not.
+ */
+export function isFlagValueToken(token) {
+    if (token === "-" || isNegativeNumberToken(token))
+        return true;
+    if (!token.startsWith("-"))
+        return true;
+    return token.startsWith("--") && token !== "--" && !LONG_FLAG_SHAPE.test(token);
+}
 export function requireFlagValue(flagLabel, next) {
-    if (next === undefined || (next !== "-" && next.startsWith("-") && !isNegativeNumberToken(next))) {
-        throw new UsageError(`Flag ${flagLabel} requires a value.`, "missing_required_flag");
+    if (next === undefined || !isFlagValueToken(next)) {
+        const inlineForm = flagLabel.startsWith("--") ? `${flagLabel}=VALUE` : undefined;
+        const hint = next === undefined || !next.startsWith("-")
+            ? undefined
+            : flagLabel === "--sql"
+                ? 'A SQL value that starts with `--` (a comment) can be passed as --sql="-- ...", from a file with --sql-file PATH, or on stdin with --stdin.'
+                : inlineForm
+                    ? `If the value itself starts with \`-\`, pass it as ${inlineForm}.`
+                    : undefined;
+        throw new UsageError(`Flag ${flagLabel} requires a value.`, "missing_required_flag", hint);
     }
     return next;
 }

package/dist/src/cli/helpers/dataset.d.ts

@@ -1,2 +1,14 @@
 import type { DatasetDetails } from "../../schemas.js";
+export interface DatasetSqlSourceFlags {
+    table?: string;
+    dbSchema?: string;
+    catalog?: string;
+    query?: string;
+}
+/**
+ * The SQL source of `dataset create` (`--table [--schema S] [--catalog C]` or
+ * `--query SQL`/`--query-file PATH`), validated against the dataset type.
+ * Empty when no SQL flag is given.
+ */
+export declare function datasetSqlSourceFromFlags(flags: Record<string, string | boolean>, dsType: string): DatasetSqlSourceFlags;
 export declare function datasetSourceSummary(details: DatasetDetails): Record<string, unknown>;

package/dist/src/cli/helpers/dataset.js

@@ -1,3 +1,39 @@
+import { assertSqlDatasetSource, } from "../../resources/dataset-create.js";
+import { readInputText, stripUtf8Bom, } from "../coerce.js";
+import { UsageError, } from "../usage.js";
+/**
+ * The SQL source of `dataset create` (`--table [--schema S] [--catalog C]` or
+ * `--query SQL`/`--query-file PATH`), validated against the dataset type.
+ * Empty when no SQL flag is given.
+ */
+export function datasetSqlSourceFromFlags(flags, dsType) {
+    const text = (flag) => {
+        const value = flags[flag];
+        if (value === undefined)
+            return undefined;
+        if (typeof value !== "string") {
+            throw new UsageError(`--${flag} requires a value.`, "missing_required_flag");
+        }
+        return value;
+    };
+    if (flags["query"] !== undefined && flags["query-file"] !== undefined) {
+        throw new UsageError("Conflicting input sources: --query, --query-file. Provide exactly one.", "conflicting_input_sources", undefined, { sources: ["query", "query-file",], });
+    }
+    const queryFile = text("query-file");
+    const inline = text("query");
+    const source = {
+        ...(text("table") !== undefined ? { table: text("table"), } : {}),
+        ...(text("schema") !== undefined ? { dbSchema: text("schema"), } : {}),
+        ...(text("catalog") !== undefined ? { catalog: text("catalog"), } : {}),
+        ...(queryFile !== undefined
+            ? { query: stripUtf8Bom(readInputText(queryFile, "--query-file")), }
+            : inline !== undefined
+                ? { query: inline, }
+                : {}),
+    };
+    assertSqlDatasetSource(dsType, source);
+    return source;
+}
 export function datasetSourceSummary(details) {
     const params = details.params ?? {};
     return {

package/dist/src/cli/helpers/flow-zone.d.ts

@@ -1,6 +1,7 @@
 import type { DataikuClient } from "../../client.js";
 import type { FlowZoneItemInput } from "../../resources/flow-zones.js";
 import type { FlowZone, FlowZoneObjectType, FlowZonePosition } from "../../schemas.js";
+import type { NormalizedFlowMap } from "../../utils/flow-map.js";
 export declare function flowZoneId(value: string): string;
 export declare function flowZoneName(value: string | boolean | undefined): string;
 export declare function flowZoneColor(value: string | boolean | undefined): string | undefined;
@@ -18,6 +19,8 @@ export interface FlowZoneOrganizeZonePlan {
     color?: string;
     position?: FlowZonePosition;
     items: FlowZoneItemInput[];
+    /** Recipe/output unit members added by {@link applyFlowZoneUnits}; also present in `items`. */
+    impliedItems?: FlowZoneItemInput[];
 }
 export interface FlowZoneOrganizePlan {
     topologyFingerprint?: string;
@@ -60,7 +63,25 @@ export declare function flowZoneExplicitItems(zone: FlowZone): FlowZoneItemInput
 export declare function flowZonePlanFromZones(zones: FlowZone[], topologyFingerprint: string): FlowZoneOrganizePlan;
 export declare function flowZoneMoveDelta(existing: FlowZone | undefined, plannedItems: FlowZoneItemInput[]): FlowZoneItemInput[];
 export declare function flowZonePruneItems(existing: FlowZone | undefined, plannedItemKeys: Set<string>): FlowZoneItemInput[];
+/**
+ * The position an existing zone must move to, if the plan changes it. DSS
+ * honors a zone position only on creation, so a move means recreating the zone.
+ */
+export declare function flowZoneRepositionTarget(plan: FlowZoneOrganizeZonePlan, existing: FlowZone): FlowZonePosition | undefined;
 export declare function flowZoneOrganizeStep(plan: FlowZoneOrganizeZonePlan, existing: FlowZone | undefined, sync: boolean, plannedItemKeys: Set<string>): Record<string, unknown>;
+/**
+ * Enforce the DSS recipe/output zone invariant on a plan. Rejects plans that
+ * place members of one unit in different zones (they would never converge),
+ * and adds the unlisted members of each planned unit to that zone as
+ * `impliedItems`, so moves, `--sync` pruning, and reruns all agree with what
+ * DSS actually does.
+ */
+export declare function applyFlowZoneUnits(plan: FlowZoneOrganizePlan, graph: NormalizedFlowMap, zones: FlowZone[], projectKey: string | undefined): FlowZoneOrganizePlan;
+/**
+ * Default-zone objects an organization plan has to place: recipes (their
+ * outputs follow) and objects no recipe produces, such as uploaded sources.
+ */
+export declare function flowZoneUnassignedItems(graph: NormalizedFlowMap, zones: FlowZone[]): FlowZoneItemInput[];
 export declare function flowZoneValidationBucket(index: FlowZoneOrganizeValidationIndex, objectType: FlowZoneObjectType): Set<string>;
 export declare function flowZoneValidationIndex(client: DataikuClient, projectKey: string | undefined): Promise<FlowZoneOrganizeValidationIndex>;
 export declare function validateFlowZoneOrganizeObjects(client: DataikuClient, plan: FlowZoneOrganizePlan, projectKey: string | undefined): Promise<FlowZoneOrganizeValidationResult>;

package/dist/src/cli/helpers/flow-zone.js

@@ -1,4 +1,5 @@
 import { readFileSync, } from "node:fs";
+import { ClientValidationError, } from "../../errors.js";
 import { asRecord, } from "../../utils/records.js";
 import { compareStrings, } from "../../utils/stable-hash.js";
 import { finiteNumberField, jsonInput, optionalStringField, parseJsonObject, requiredStringArray, splitCsvFlag, } from "../coerce.js";
@@ -319,6 +320,16 @@ export function flowZonePruneItems(existing, plannedItemKeys) {
         return [];
     return flowZoneExplicitItems(existing).filter((item) => !plannedItemKeys.has(flowZoneItemKey(item)));
 }
+/**
+ * The position an existing zone must move to, if the plan changes it. DSS
+ * honors a zone position only on creation, so a move means recreating the zone.
+ */
+export function flowZoneRepositionTarget(plan, existing) {
+    return plan.position !== undefined
+        && !flowZoneSamePosition(flowZoneCurrentPosition(existing), plan.position)
+        ? plan.position
+        : undefined;
+}
 export function flowZoneOrganizeStep(plan, existing, sync, plannedItemKeys) {
     ensureFlowZonePlanTarget(plan, existing);
     const update = {};
@@ -326,10 +337,8 @@ export function flowZoneOrganizeStep(plan, existing, sync, plannedItemKeys) {
         update.name = plan.name;
     if (existing && plan.color && plan.color !== existing.color)
         update.color = plan.color;
-    if (existing && plan.position !== undefined
-        && !flowZoneSamePosition(flowZoneCurrentPosition(existing), plan.position)) {
-        update.position = plan.position;
-    }
+    const recreatePosition = existing ? flowZoneRepositionTarget(plan, existing) : undefined;
+    const recreate = recreatePosition ? { position: recreatePosition, } : undefined;
     const pruneItems = sync ? flowZonePruneItems(existing, plannedItemKeys) : [];
     const moveItems = flowZoneMoveDelta(existing, plan.items);
     return {
@@ -341,10 +350,141 @@ export function flowZoneOrganizeStep(plan, existing, sync, plannedItemKeys) {
         },
         ...(existing ? { existing: flowZoneSummary(existing), } : { create: true, }),
         ...(Object.keys(update).length > 0 ? { update, } : {}),
+        ...(recreate ? { recreate, } : {}),
         moveItems,
+        ...(plan.impliedItems && plan.impliedItems.length > 0
+            ? { impliedItems: plan.impliedItems, }
+            : {}),
         ...(pruneItems.length > 0 ? { pruneItems, } : {}),
     };
 }
+function flowNodeObjectType(node, knownTypes) {
+    switch (node.kind) {
+        case "recipe":
+            return "RECIPE";
+        case "dataset":
+            return "DATASET";
+        case "folder":
+            return "MANAGED_FOLDER";
+        default:
+            return knownTypes.get(node.id);
+    }
+}
+/**
+ * DSS keeps a recipe and its outputs in one zone: moving either drags the
+ * others. Each unit is keyed by its recipe id and lists the recipe plus every
+ * object the recipe writes.
+ */
+function flowZoneUnits(graph) {
+    const kindById = new Map(graph.nodes.map((node) => [node.id, node.kind,]));
+    const units = new Map();
+    for (const node of graph.nodes) {
+        if (node.kind === "recipe")
+            units.set(node.id, [node.id,]);
+    }
+    for (const edge of graph.edges) {
+        if (kindById.get(edge.from) !== "recipe" || kindById.get(edge.to) === "recipe")
+            continue;
+        units.get(edge.from)?.push(edge.to);
+    }
+    return units;
+}
+function explicitTypesById(zones) {
+    const types = new Map();
+    for (const zone of zones) {
+        for (const item of flowZoneItems(zone)) {
+            if (!item.projectKey)
+                types.set(item.objectId, item.objectType);
+        }
+    }
+    return types;
+}
+/**
+ * Enforce the DSS recipe/output zone invariant on a plan. Rejects plans that
+ * place members of one unit in different zones (they would never converge),
+ * and adds the unlisted members of each planned unit to that zone as
+ * `impliedItems`, so moves, `--sync` pruning, and reruns all agree with what
+ * DSS actually does.
+ */
+export function applyFlowZoneUnits(plan, graph, zones, projectKey) {
+    const zoneIndexById = new Map();
+    plan.zones.forEach((zonePlan, index) => {
+        for (const item of zonePlan.items) {
+            // Shared objects from other projects never move with a local recipe.
+            if (!item.projectKey || item.projectKey === projectKey)
+                zoneIndexById.set(item.objectId, index);
+        }
+    });
+    const nodeById = new Map(graph.nodes.map((node) => [node.id, node,]));
+    const knownTypes = explicitTypesById(zones);
+    const conflicts = [];
+    const implied = plan.zones.map(() => []);
+    for (const [recipe, members,] of flowZoneUnits(graph)) {
+        const planned = members.filter((member) => zoneIndexById.has(member));
+        if (planned.length === 0)
+            continue;
+        const indexes = new Set(planned.map((member) => zoneIndexById.get(member)));
+        if (indexes.size > 1) {
+            const byZone = {};
+            for (const member of planned) {
+                const label = flowZonePlanLabel(plan.zones[zoneIndexById.get(member)]);
+                (byZone[label] ??= []).push(member);
+            }
+            conflicts.push({ recipe, zones: byZone, });
+            continue;
+        }
+        const [index,] = indexes;
+        for (const member of members) {
+            if (zoneIndexById.has(member))
+                continue;
+            const node = nodeById.get(member);
+            const objectType = node ? flowNodeObjectType(node, knownTypes) : undefined;
+            if (objectType)
+                implied[index].push({ objectType, objectId: member, });
+        }
+    }
+    if (conflicts.length > 0) {
+        throw new ClientValidationError(`Flow zone plan splits ${conflicts.length} recipe(s) from their outputs across zones; DSS keeps a recipe and its outputs in one zone.`, "validation_failed", "Assign each recipe to one zone (its outputs follow automatically), or list the recipe and all its outputs in the same zone.", { conflicts, });
+    }
+    return {
+        ...plan,
+        zones: plan.zones.map((zonePlan, index) => implied[index].length === 0
+            ? zonePlan
+            : {
+                ...zonePlan,
+                items: [...zonePlan.items, ...implied[index],],
+                impliedItems: implied[index],
+            }),
+    };
+}
+/**
+ * Default-zone objects an organization plan has to place: recipes (their
+ * outputs follow) and objects no recipe produces, such as uploaded sources.
+ */
+export function flowZoneUnassignedItems(graph, zones) {
+    const assigned = new Set();
+    for (const zone of zones) {
+        if (zone.id === "default")
+            continue;
+        for (const item of flowZoneExplicitItems(zone))
+            assigned.add(item.objectId);
+    }
+    const produced = new Set();
+    for (const members of flowZoneUnits(graph).values()) {
+        for (const member of members.slice(1))
+            produced.add(member);
+    }
+    const knownTypes = explicitTypesById(zones);
+    const items = [];
+    for (const node of graph.nodes) {
+        if (assigned.has(node.id) || produced.has(node.id))
+            continue;
+        const objectType = flowNodeObjectType(node, knownTypes);
+        if (objectType)
+            items.push({ objectType, objectId: node.id, });
+    }
+    return items.sort((a, b) => compareStrings(flowZoneItemKey(a), flowZoneItemKey(b)));
+}
 export function flowZoneValidationBucket(index, objectType) {
     switch (objectType) {
         case "DATASET":

package/dist/src/cli/output-schemas.js

@@ -13,6 +13,7 @@
  * Imported by the generator and the discovery parity test only.
  */
 import { compactListOutputSchemas, } from "./list-shapes.js";
+import { compactReadOutputSchemas, DATASET_GET_DROPPED_KEYS, PROJECT_GET_DROPPED_KEYS, } from "./read-shapes.js";
 const PROJECT_LIBRARY_ITEM_OUTPUT_SCHEMA = {
     type: "object",
     additionalProperties: false,
@@ -50,6 +51,21 @@ const NOTEBOOK_SAVE_SQL_OUTPUT_SCHEMA = {
         requested: { type: "string", },
     },
 };
+/**
+ * Discovery schema of a compact settings object (`dataset get`, `project get`):
+ * the SDK TypeBox schema minus the keys the CLI drops, with only the
+ * identifiers that survive pruning required. SDK validation keeps the
+ * unmodified TypeBox schema.
+ */
+function settingsOutputSchema(schema, droppedKeys, extraProperties = {}) {
+    const properties = Object.fromEntries(Object.entries(schema["properties"]).filter(([key,]) => !droppedKeys.includes(key)));
+    const required = (schema["required"] ?? []).filter((key) => !droppedKeys.includes(key));
+    return {
+        ...schema,
+        properties: { ...properties, ...extraProperties, },
+        required: [...required, ...Object.keys(extraProperties),],
+    };
+}
 let commandOutputSchemas;
 /**
  * Canonical TypeBox-derived output schemas, keyed by `resource.action`. This is
@@ -196,9 +212,15 @@ export function typeBoxCommandOutputSchemas() {
                 maxLines: { type: "integer", minimum: 0, },
             },
         },
-        "project.get": ProjectDetailsSchema,
+        "project.get": settingsOutputSchema(ProjectDetailsSchema, PROJECT_GET_DROPPED_KEYS, {
+            deniedPermissions: {
+                type: "array",
+                items: { type: "string", },
+                description: "Permission flags DSS reports as false; absent flags are granted.",
+            },
+        }),
         "project.metadata": ProjectMetadataSchema,
-        "dataset.get": DatasetDetailsSchema,
+        "dataset.get": settingsOutputSchema(DatasetDetailsSchema, DATASET_GET_DROPPED_KEYS),
         "dataset.schema": DatasetSchemaSchema,
         "job.wait": JobWaitResultSchema,
         "job.monitor": JobWaitResultSchema,
@@ -224,7 +246,9 @@ export function typeBoxCommandOutputSchemas() {
                 },
             ],
         },
-        // `*.list` defaults to compact items; `--full` returns the DSS objects.
+        // `*.list` and the four large reads default to compact shapes; `--full`
+        // returns the DSS objects.
         ...compactListOutputSchemas(),
+        ...compactReadOutputSchemas(),
     };
 }

package/dist/src/cli/output.js

@@ -187,6 +187,12 @@ export class CommandResultFailure extends Error {
 export function commandFailureMessage(result) {
     if (isFailedWaitResult(result)) {
         const record = result;
+        const failure = record.failure;
+        if (failure !== null && typeof failure === "object" && !Array.isArray(failure)) {
+            const message = failure.message;
+            if (typeof message === "string" && message.length > 0)
+                return message;
+        }
         const state = typeof record.state === "string"
             ? record.state
             : typeof record.outcome === "string"