@thinkingai/ae-cli 6.0.46 → 6.0.47

package/dist/{te-dataops-6P5IKWNJ.js → te-dataops-TXLKM2W6.js}

@@ -1,26 +1,27 @@
+import { createRequire as __createRequire } from 'node:module'; const require = __createRequire(import.meta.url);
 import {
   printError
-} from "./chunk-BYYS3ANB.js";
+} from "./chunk-KEWVSO64.js";
 import {
   internalCallSourceHeaders
-} from "./chunk-SERWF6G5.js";
+} from "./chunk-Y74WTIKJ.js";
 import {
   clearCliToken,
   getCliToken
-} from "./chunk-J2DEBMRF.js";
+} from "./chunk-RWXIXOZG.js";
 import {
   resolveHost
-} from "./chunk-ZQKDZXDO.js";
+} from "./chunk-O6K2ODUE.js";
 import {
   safeJsonParse
-} from "./chunk-3FY3RJ26.js";
+} from "./chunk-KZ6ZHF5J.js";
 import {
   CliValidationError,
   PermissionError
-} from "./chunk-UW5UN47B.js";
+} from "./chunk-533JK3YX.js";
 import {
   logger
-} from "./chunk-JHENBQ5B.js";
+} from "./chunk-FR2EDAQM.js";
 
 // src/commands/te-dataops/shared.ts
 import { randomBytes } from "crypto";
@@ -60,6 +61,15 @@ var TOOL_API_MAP = {
   operations_get_flow_instance_detail: { method: "GET", path: "/api/cli/dataops/v1/gaia/operations/flow-instances/detail" },
   operations_get_task_instance_detail: { method: "GET", path: "/api/cli/dataops/v1/gaia/operations/task-instances/detail" },
   operations_stop_flow_instance: { method: "POST", path: "/api/cli/dataops/v1/gaia/operations/flow-instances/stop" },
+  operations_list_backfill_flows: { method: "GET", path: "/api/cli/dataops/v1/gaia/operations/backfill/flows" },
+  operations_create_backfill_job: { method: "POST", path: "/api/cli/dataops/v1/gaia/operations/backfill/jobs" },
+  operations_update_backfill_job: { method: "POST", path: "/api/cli/dataops/v1/gaia/operations/backfill/jobs/update" },
+  operations_delete_backfill_job: { method: "POST", path: "/api/cli/dataops/v1/gaia/operations/backfill/jobs/delete" },
+  operations_run_backfill_job: { method: "POST", path: "/api/cli/dataops/v1/gaia/operations/backfill/jobs/run" },
+  operations_search_backfill_jobs: { method: "POST", path: "/api/cli/dataops/v1/gaia/operations/backfill/jobs/search" },
+  operations_get_backfill_job_detail: { method: "GET", path: "/api/cli/dataops/v1/gaia/operations/backfill/jobs/detail" },
+  operations_stop_backfill_job: { method: "POST", path: "/api/cli/dataops/v1/gaia/operations/backfill/jobs/stop" },
+  operations_rerun_backfill_job: { method: "POST", path: "/api/cli/dataops/v1/gaia/operations/backfill/jobs/rerun" },
   integration_list_datasource_components: { method: "GET", path: "/api/cli/dataops/v1/gaia/integration/datasource-components" },
   integration_get_datasource_component_template: { method: "GET", path: "/api/cli/dataops/v1/gaia/integration/datasource-component-template" },
   integration_list_space_datasources: { method: "GET", path: "/api/cli/dataops/v1/gaia/integration/datasources" },
@@ -89,10 +99,10 @@ var TOOL_API_MAP = {
   ide_get_sql_query_status: { method: "GET", path: "/api/cli/dataops/v1/gaia/ide/sql-query-status" },
   ide_cancel_sql_query: { method: "POST", path: "/api/cli/dataops/v1/gaia/ide/sql-query-cancel" }
 };
-async function callDataopsApi(ctx, toolName59, args = {}) {
-  const spec = TOOL_API_MAP[toolName59];
+async function callDataopsApi(ctx, toolName68, args = {}) {
+  const spec = TOOL_API_MAP[toolName68];
   if (!spec) {
-    throw new Error(`DataOps API mapping not found for tool: ${toolName59}`);
+    throw new Error(`DataOps API mapping not found for tool: ${toolName68}`);
   }
   const params = compactArgs(args);
   if (spec.method === "GET") {
@@ -100,10 +110,10 @@ async function callDataopsApi(ctx, toolName59, args = {}) {
   }
   return dataopsRequest(ctx, spec.method, spec.path, {}, params);
 }
-function buildDataopsApiDryRun(ctx, toolName59, args = {}) {
-  const spec = TOOL_API_MAP[toolName59];
+function buildDataopsApiDryRun(ctx, toolName68, args = {}) {
+  const spec = TOOL_API_MAP[toolName68];
   if (!spec) {
-    throw new Error(`DataOps API mapping not found for tool: ${toolName59}`);
+    throw new Error(`DataOps API mapping not found for tool: ${toolName68}`);
   }
   const params = compactArgs(args);
   if (spec.method === "GET") {
@@ -1689,8 +1699,223 @@ var commands3 = [
 ];
 var integration_default = commands3;
 
+// src/commands/te-dataops/operations/backfill-options.ts
+var ISO_DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
+function backfillJobFlags() {
+  return [
+    { name: "spaceCode", type: "string", required: true, desc: "Space code" },
+    { name: "jobId", type: "number", required: true, desc: "Backfill job ID" }
+  ];
+}
+function buildBackfillJobArgs(ctx) {
+  return {
+    spaceCode: ctx.str("spaceCode"),
+    jobId: ctx.num("jobId")
+  };
+}
+function validateBackfillJobId(ctx) {
+  validatePositiveSafeInteger(ctx, "jobId");
+}
+function validatePositiveSafeInteger(ctx, name, required = true) {
+  const raw = ctx.str(name).trim();
+  if (!required && raw === "") return;
+  if (!/^[1-9]\d*$/.test(raw) || !Number.isSafeInteger(Number(raw))) {
+    throw new CliValidationError(`--${name} must be a positive safe integer`, {
+      location: { field: name }
+    });
+  }
+}
+function optionalBoolean(ctx, name, defaultValue) {
+  return ctx.str(name) === "" ? defaultValue : ctx.bool(name);
+}
+function hasValue(ctx, name) {
+  return ctx.str(name) !== "";
+}
+function validateEnum(ctx, name, allowed) {
+  const value = ctx.str(name).trim();
+  if (value !== "" && !allowed.includes(value)) {
+    throw new CliValidationError(`--${name} must be ${formatAllowed(allowed)}`, {
+      location: { field: name }
+    });
+  }
+}
+function validateIsoDate(value, name) {
+  if (!ISO_DATE_PATTERN.test(value)) {
+    throw invalidDate(name);
+  }
+  const [year, month, day] = value.split("-").map(Number);
+  const timestamp = Date.UTC(year, month - 1, day);
+  const parsed = new Date(timestamp);
+  if (parsed.getUTCFullYear() !== year || parsed.getUTCMonth() !== month - 1 || parsed.getUTCDate() !== day) {
+    throw invalidDate(name);
+  }
+  return timestamp;
+}
+function validateDateRange(startDate, endDate) {
+  const start = validateIsoDate(startDate, "startDate");
+  const end = validateIsoDate(endDate, "endDate");
+  if (start > end) {
+    throw new CliValidationError("--startDate must not be after --endDate", {
+      location: { field: "startDate" }
+    });
+  }
+}
+function invalidDate(name) {
+  return new CliValidationError(`--${name} must be a valid date in yyyy-MM-dd format`, {
+    location: { field: name }
+  });
+}
+function formatAllowed(allowed) {
+  if (allowed.length === 1) return allowed[0];
+  if (allowed.length === 2) return `${allowed[0]} or ${allowed[1]}`;
+  return `${allowed.slice(0, -1).join(", ")}, or ${allowed.at(-1)}`;
+}
+
+// src/commands/te-dataops/operations/create-backfill-job.ts
+var toolName45 = "operations_create_backfill_job";
+var JOB_TYPES = ["TASK_ALL", "TASK_ONLY", "TASK_PRE", "TASK_POST"];
+var FAILURE_STRATEGIES = ["END", "CONTINUE"];
+var INTERVAL_UNITS = ["DAY", "WEEK", "MONTH"];
+var ST_TIME_PATTERN = /^(?:[01]\d|2[0-3]):[0-5]\d:[0-5]\d$/;
+function buildBackfillDraftArgs(ctx) {
+  const customDates = hasValue(ctx, "completeDates");
+  return {
+    spaceCode: ctx.str("spaceCode"),
+    jobName: ctx.str("jobName"),
+    flowCode: ctx.num("flowCode"),
+    jobType: ctx.str("jobType") || "TASK_ALL",
+    startNode: ctx.optionalNum("startNode"),
+    failureStrategy: ctx.str("failureStrategy") || "END",
+    parallel: optionalBoolean(ctx, "parallel", true),
+    completeDates: customDates ? ctx.json("completeDates") : void 0,
+    startDate: ctx.str("startDate"),
+    endDate: ctx.str("endDate"),
+    step: customDates ? void 0 : ctx.optionalNum("step") ?? 1,
+    unit: customDates ? void 0 : ctx.str("unit") || "DAY",
+    reverse: optionalBoolean(ctx, "reverse", false),
+    stTime: ctx.str("stTime")
+  };
+}
+function validateBackfillDraft(ctx) {
+  validatePositiveSafeInteger(ctx, "flowCode");
+  if (ctx.str("jobName").trim() === "") {
+    throw new CliValidationError("--jobName must be non-empty", {
+      location: { field: "jobName" }
+    });
+  }
+  validateEnum(ctx, "jobType", JOB_TYPES);
+  validateEnum(ctx, "failureStrategy", FAILURE_STRATEGIES);
+  const jobType = ctx.str("jobType") || "TASK_ALL";
+  const hasStartNode = hasValue(ctx, "startNode");
+  if (jobType !== "TASK_ALL" && !hasStartNode) {
+    throw new CliValidationError("--startNode is required when --jobType is not TASK_ALL", {
+      location: { field: "startNode" }
+    });
+  }
+  if (hasStartNode) validatePositiveSafeInteger(ctx, "startNode");
+  const stTime = ctx.str("stTime");
+  if (stTime !== "" && !ST_TIME_PATTERN.test(stTime)) {
+    throw new CliValidationError("--stTime must use HH:mm:ss in 24-hour time", {
+      location: { field: "stTime" }
+    });
+  }
+  const hasCustomDates = hasValue(ctx, "completeDates");
+  const hasStartDate = hasValue(ctx, "startDate");
+  const hasEndDate = hasValue(ctx, "endDate");
+  if (!hasStartDate || !hasEndDate) {
+    throw new CliValidationError("Pass both --startDate and --endDate");
+  }
+  const startDate = ctx.str("startDate");
+  const endDate = ctx.str("endDate");
+  validateDateRange(startDate, endDate);
+  if (hasCustomDates) {
+    const dates = validateCompleteDates(ctx.json("completeDates"));
+    if (dates.some((date) => date < startDate || date > endDate)) {
+      throw new CliValidationError("--completeDates values must be inside --startDate and --endDate", {
+        location: { field: "completeDates" }
+      });
+    }
+    return;
+  }
+  const step = ctx.optionalNum("step") ?? 1;
+  if (!Number.isInteger(step) || step < 1) {
+    throw new CliValidationError("--step must be a positive integer", {
+      location: { field: "step" }
+    });
+  }
+  validateEnumValue(ctx.str("unit") || "DAY", "unit", INTERVAL_UNITS);
+}
+function validateCompleteDates(value) {
+  if (!Array.isArray(value) || value.length === 0) {
+    throw new CliValidationError("--completeDates must be a non-empty JSON array of yyyy-MM-dd strings", {
+      location: { field: "completeDates" }
+    });
+  }
+  const dates = value;
+  if (!dates.every((date) => typeof date === "string")) {
+    throw new CliValidationError("--completeDates must contain only yyyy-MM-dd strings", {
+      location: { field: "completeDates" }
+    });
+  }
+  for (const date of dates) validateIsoDate(date, "completeDates");
+  if (new Set(dates).size !== dates.length) {
+    throw new CliValidationError("--completeDates must not contain duplicate dates", {
+      location: { field: "completeDates" }
+    });
+  }
+  return dates;
+}
+function validateEnumValue(value, name, allowed) {
+  if (!allowed.includes(value)) {
+    throw new CliValidationError(`--${name} must be DAY, WEEK, or MONTH`, {
+      location: { field: name }
+    });
+  }
+}
+var createBackfillJob = {
+  service: "dataops_operations",
+  command: "+create_backfill_job",
+  description: "Create a DRAFT backfill job for one PROD task flow. Always pass a date range; completeDates optionally selects dates inside it. Creation never starts the job.",
+  flags: backfillDraftFlags(),
+  risk: "write",
+  validate: validateBackfillDraft,
+  dryRun: (ctx) => buildDataopsApiDryRun(ctx, toolName45, buildBackfillDraftArgs(ctx)),
+  execute: async (ctx) => callDataopsApi(ctx, toolName45, buildBackfillDraftArgs(ctx))
+};
+function backfillDraftFlags() {
+  return [
+    { name: "spaceCode", type: "string", required: true, desc: "Space code" },
+    { name: "jobName", type: "string", required: true, maxLength: 50, desc: "Backfill job name, up to 50 characters" },
+    { name: "flowCode", type: "number", required: true, desc: "PROD task flow code from +list_backfill_flows" },
+    { name: "jobType", type: "string", required: false, default: "TASK_ALL", desc: "Backfill scope: TASK_ALL, TASK_ONLY, TASK_PRE, or TASK_POST. Default TASK_ALL" },
+    { name: "startNode", type: "number", required: false, desc: "Start task code. Required when jobType is not TASK_ALL" },
+    { name: "failureStrategy", type: "string", required: false, default: "END", desc: "Failure strategy: END or CONTINUE. Default END" },
+    { name: "parallel", type: "boolean", required: false, default: true, desc: "Whether plans may run in parallel. Default true" },
+    { name: "completeDates", type: "json", required: false, desc: "Optional non-empty JSON array of unique base dates inside the configured range" },
+    { name: "startDate", type: "string", required: true, desc: "Range start date in yyyy-MM-dd format" },
+    { name: "endDate", type: "string", required: true, desc: "Range end date in yyyy-MM-dd format" },
+    { name: "step", type: "number", required: false, default: 1, min: 1, desc: "Positive interval step for range mode. Default 1" },
+    { name: "unit", type: "string", required: false, default: "DAY", desc: "Range interval unit: DAY, WEEK, or MONTH. Default DAY" },
+    { name: "reverse", type: "boolean", required: false, default: false, desc: "Generate plans in reverse date order. Default false" },
+    { name: "stTime", type: "string", required: false, desc: "Scheduler time in HH:mm:ss; required when the selected flow reports hasSt=true" }
+  ];
+}
+
+// src/commands/te-dataops/operations/delete-backfill-job.ts
+var toolName46 = "operations_delete_backfill_job";
+var deleteBackfillJob = {
+  service: "dataops_operations",
+  command: "+delete_backfill_job",
+  description: "Delete one backfill job. The server permits deletion only in supported terminal or draft states.",
+  flags: backfillJobFlags(),
+  risk: "high-risk-write",
+  validate: validateBackfillJobId,
+  dryRun: (ctx) => buildDataopsApiDryRun(ctx, toolName46, buildBackfillJobArgs(ctx)),
+  execute: async (ctx) => callDataopsApi(ctx, toolName46, buildBackfillJobArgs(ctx))
+};
+
 // src/commands/te-dataops/operations/get-flow-instance-detail.ts
-var toolName45 = "operations_get_flow_instance_detail";
+var toolName47 = "operations_get_flow_instance_detail";
 function buildArgs42(ctx) {
   return {
     spaceCode: ctx.str("spaceCode"),
@@ -1708,14 +1933,27 @@ var getFlowInstanceDetail = {
     { name: "flowInstanceId", type: "number", required: true, desc: "Workflow instance ID from +search_flow_instances" }
   ],
   risk: "read",
-  dryRun: (ctx) => buildDataopsApiDryRun(ctx, toolName45, buildArgs42(ctx)),
+  dryRun: (ctx) => buildDataopsApiDryRun(ctx, toolName47, buildArgs42(ctx)),
   execute: async (ctx) => {
-    return callDataopsApi(ctx, toolName45, buildArgs42(ctx));
+    return callDataopsApi(ctx, toolName47, buildArgs42(ctx));
   }
 };
 
+// src/commands/te-dataops/operations/get-backfill-job-detail.ts
+var toolName48 = "operations_get_backfill_job_detail";
+var getBackfillJobDetail = {
+  service: "dataops_operations",
+  command: "+get_backfill_job_detail",
+  description: "Get one backfill job and its plans. A DRAFT job has an empty plans list because it has not run yet.",
+  flags: backfillJobFlags(),
+  risk: "read",
+  validate: validateBackfillJobId,
+  dryRun: (ctx) => buildDataopsApiDryRun(ctx, toolName48, buildBackfillJobArgs(ctx)),
+  execute: async (ctx) => callDataopsApi(ctx, toolName48, buildBackfillJobArgs(ctx))
+};
+
 // src/commands/te-dataops/operations/get-task-instance-detail.ts
-var toolName46 = "operations_get_task_instance_detail";
+var toolName49 = "operations_get_task_instance_detail";
 function optionalBool2(ctx, name) {
   return ctx.str(name) === "" ? void 0 : ctx.bool(name);
 }
@@ -1744,15 +1982,127 @@ var getTaskInstanceDetail = {
     { name: "includeLog", type: "boolean", required: false, desc: "Whether to include task logs. Default false" }
   ],
   risk: "read",
-  dryRun: (ctx) => buildDataopsApiDryRun(ctx, toolName46, buildArgs43(ctx)),
+  dryRun: (ctx) => buildDataopsApiDryRun(ctx, toolName49, buildArgs43(ctx)),
   execute: async (ctx) => {
-    return callDataopsApi(ctx, toolName46, buildArgs43(ctx));
+    return callDataopsApi(ctx, toolName49, buildArgs43(ctx));
   }
 };
 
-// src/commands/te-dataops/operations/search-flow-instances.ts
-var toolName47 = "operations_search_flow_instances";
+// src/commands/te-dataops/operations/list-backfill-flows.ts
+var toolName50 = "operations_list_backfill_flows";
 function buildArgs44(ctx) {
+  return { spaceCode: ctx.str("spaceCode") };
+}
+var listBackfillFlows = {
+  service: "dataops_operations",
+  command: "+list_backfill_flows",
+  description: "List PROD task flows that can be used to create a backfill job. Returns each flow code, name, and backfill eligibility information such as canRun and hasSt.",
+  flags: [
+    { name: "spaceCode", type: "string", required: true, desc: "Space code" }
+  ],
+  risk: "read",
+  dryRun: (ctx) => buildDataopsApiDryRun(ctx, toolName50, buildArgs44(ctx)),
+  execute: async (ctx) => callDataopsApi(ctx, toolName50, buildArgs44(ctx))
+};
+
+// src/commands/te-dataops/operations/rerun-backfill-job.ts
+var toolName51 = "operations_rerun_backfill_job";
+var rerunBackfillJob = {
+  service: "dataops_operations",
+  command: "+rerun_backfill_job",
+  description: "Rerun every plan in an existing terminal backfill job. This reuses the job and does not rerun only failed plans.",
+  flags: backfillJobFlags(),
+  risk: "write",
+  validate: validateBackfillJobId,
+  dryRun: (ctx) => buildDataopsApiDryRun(ctx, toolName51, buildBackfillJobArgs(ctx)),
+  execute: async (ctx) => callDataopsApi(ctx, toolName51, buildBackfillJobArgs(ctx))
+};
+
+// src/commands/te-dataops/operations/run-backfill-job.ts
+var toolName52 = "operations_run_backfill_job";
+var runBackfillJob = {
+  service: "dataops_operations",
+  command: "+run_backfill_job",
+  description: "Run an existing DRAFT backfill job. This is separate from creation and generates the job plans on the server.",
+  flags: backfillJobFlags(),
+  risk: "write",
+  validate: validateBackfillJobId,
+  dryRun: (ctx) => buildDataopsApiDryRun(ctx, toolName52, buildBackfillJobArgs(ctx)),
+  execute: async (ctx) => callDataopsApi(ctx, toolName52, buildBackfillJobArgs(ctx))
+};
+
+// src/commands/te-dataops/operations/search-backfill-jobs.ts
+var toolName53 = "operations_search_backfill_jobs";
+var JOB_TYPES2 = ["TASK_ALL", "TASK_ONLY", "TASK_PRE", "TASK_POST"];
+var JOB_STATUSES = ["DRAFT", "RUNNING", "STOP", "FAIL", "SUCCESS", "READY_STOP"];
+var JOB_SORTS = ["ID", "JOB_NAME", "CREATE_TIME", "UPDATE_TIME", "START_DATE", "END_DATE"];
+function buildArgs45(ctx) {
+  return {
+    spaceCode: ctx.str("spaceCode"),
+    keyword: ctx.str("keyword"),
+    startDate: ctx.str("startDate"),
+    endDate: ctx.str("endDate"),
+    jobType: ctx.str("jobType"),
+    status: ctx.str("status"),
+    owners: hasValue(ctx, "owners") ? ctx.json("owners") : void 0,
+    sort: ctx.str("sort"),
+    sortAscending: optionalBoolean(ctx, "sortAscending"),
+    pageNum: ctx.optionalNum("pageNum"),
+    pageSize: ctx.optionalNum("pageSize")
+  };
+}
+function validateSearch(ctx) {
+  const startDate = ctx.str("startDate");
+  const endDate = ctx.str("endDate");
+  if (startDate !== "") validateIsoDate(startDate, "startDate");
+  if (endDate !== "") validateIsoDate(endDate, "endDate");
+  if (startDate !== "" && endDate !== "") validateDateRange(startDate, endDate);
+  validateEnum(ctx, "jobType", JOB_TYPES2);
+  validateEnum(ctx, "sort", JOB_SORTS);
+  const status = ctx.str("status");
+  if (status !== "") {
+    const statuses = status.split(",").map((value) => value.trim());
+    if (statuses.some((value) => !JOB_STATUSES.includes(value))) {
+      throw new CliValidationError(`--status must contain only: ${JOB_STATUSES.join(", ")}`, {
+        location: { field: "status" }
+      });
+    }
+  }
+  if (hasValue(ctx, "owners")) {
+    const owners = ctx.json("owners");
+    if (!Array.isArray(owners) || owners.some((owner) => typeof owner !== "string" || owner.trim() === "")) {
+      throw new CliValidationError("--owners must be a JSON array of non-empty strings", {
+        location: { field: "owners" }
+      });
+    }
+  }
+}
+var searchBackfillJobs = {
+  service: "dataops_operations",
+  command: "+search_backfill_jobs",
+  description: "Search backfill jobs in a space. Filters and pagination are optional; use jobId from the result for detail and lifecycle actions.",
+  flags: [
+    { name: "spaceCode", type: "string", required: true, desc: "Space code" },
+    { name: "keyword", type: "string", required: false, desc: "Optional job ID, job name, flow name, or remark keyword" },
+    { name: "startDate", type: "string", required: false, desc: "Optional execution start date in yyyy-MM-dd format" },
+    { name: "endDate", type: "string", required: false, desc: "Optional execution end date in yyyy-MM-dd format" },
+    { name: "jobType", type: "string", required: false, desc: "Optional job type: TASK_ALL, TASK_ONLY, TASK_PRE, or TASK_POST" },
+    { name: "status", type: "string", required: false, desc: "Optional comma-separated statuses: DRAFT,RUNNING,STOP,FAIL,SUCCESS,READY_STOP" },
+    { name: "owners", type: "json", required: false, desc: "Optional JSON array of owner open IDs" },
+    { name: "sort", type: "string", required: false, desc: "Optional sort field: ID, JOB_NAME, CREATE_TIME, UPDATE_TIME, START_DATE, or END_DATE" },
+    { name: "sortAscending", type: "boolean", required: false, desc: "Sort ascending when true; server default is descending" },
+    { name: "pageNum", type: "number", required: false, min: 1, desc: "Optional page number; server default 1" },
+    { name: "pageSize", type: "number", required: false, min: 1, max: 100, desc: "Optional page size; server default 20, max 100" }
+  ],
+  risk: "read",
+  validate: validateSearch,
+  dryRun: (ctx) => buildDataopsApiDryRun(ctx, toolName53, buildArgs45(ctx)),
+  execute: async (ctx) => callDataopsApi(ctx, toolName53, buildArgs45(ctx))
+};
+
+// src/commands/te-dataops/operations/search-flow-instances.ts
+var toolName54 = "operations_search_flow_instances";
+function buildArgs46(ctx) {
   return {
     spaceCode: ctx.str("spaceCode"),
     keyword: ctx.str("keyword"),
@@ -1777,15 +2127,28 @@ var searchFlowInstances = {
     { name: "pageSize", type: "number", required: false, desc: "Optional page size; default 20, max 100" }
   ],
   risk: "read",
-  dryRun: (ctx) => buildDataopsApiDryRun(ctx, toolName47, buildArgs44(ctx)),
+  dryRun: (ctx) => buildDataopsApiDryRun(ctx, toolName54, buildArgs46(ctx)),
   execute: async (ctx) => {
-    return callDataopsApi(ctx, toolName47, buildArgs44(ctx));
+    return callDataopsApi(ctx, toolName54, buildArgs46(ctx));
   }
 };
 
+// src/commands/te-dataops/operations/stop-backfill-job.ts
+var toolName55 = "operations_stop_backfill_job";
+var stopBackfillJob = {
+  service: "dataops_operations",
+  command: "+stop_backfill_job",
+  description: "Stop a RUNNING backfill job and its unfinished plans. This is a high-impact operation and requires confirmation.",
+  flags: backfillJobFlags(),
+  risk: "high-risk-write",
+  validate: validateBackfillJobId,
+  dryRun: (ctx) => buildDataopsApiDryRun(ctx, toolName55, buildBackfillJobArgs(ctx)),
+  execute: async (ctx) => callDataopsApi(ctx, toolName55, buildBackfillJobArgs(ctx))
+};
+
 // src/commands/te-dataops/operations/stop-flow-instance.ts
-var toolName48 = "operations_stop_flow_instance";
-function buildArgs45(ctx) {
+var toolName56 = "operations_stop_flow_instance";
+function buildArgs47(ctx) {
   const executeId = ctx.optionalNum("executeId");
   const flowInstanceId = ctx.optionalNum("flowInstanceId");
   if (executeId == null && flowInstanceId == null || executeId != null && flowInstanceId != null) {
@@ -1812,32 +2175,69 @@ var stopFlowInstance = {
     { name: "flowInstanceId", type: "number", required: false, desc: "Workflow instance ID returned by dataops_operations +search_flow_instances" }
   ],
   risk: "write",
-  dryRun: (ctx) => buildDataopsApiDryRun(ctx, toolName48, buildArgs45(ctx)),
+  dryRun: (ctx) => buildDataopsApiDryRun(ctx, toolName56, buildArgs47(ctx)),
   execute: async (ctx) => {
-    return callDataopsApi(ctx, toolName48, buildArgs45(ctx));
+    return callDataopsApi(ctx, toolName56, buildArgs47(ctx));
   }
 };
 
+// src/commands/te-dataops/operations/update-backfill-job.ts
+var toolName57 = "operations_update_backfill_job";
+function buildArgs48(ctx) {
+  return {
+    ...buildBackfillDraftArgs(ctx),
+    jobId: ctx.num("jobId")
+  };
+}
+function validateUpdate(ctx) {
+  validateBackfillJobId(ctx);
+  validateBackfillDraft(ctx);
+}
+var [spaceCodeFlag, ...draftFlags] = backfillDraftFlags();
+var updateBackfillJob = {
+  service: "dataops_operations",
+  command: "+update_backfill_job",
+  description: "Replace the complete configuration of a DRAFT backfill job. This does not start the job.",
+  flags: [
+    spaceCodeFlag,
+    { name: "jobId", type: "number", required: true, desc: "DRAFT backfill job ID" },
+    ...draftFlags
+  ],
+  risk: "write",
+  validate: validateUpdate,
+  dryRun: (ctx) => buildDataopsApiDryRun(ctx, toolName57, buildArgs48(ctx)),
+  execute: async (ctx) => callDataopsApi(ctx, toolName57, buildArgs48(ctx))
+};
+
 // src/commands/te-dataops/operations/index.ts
 var commands4 = [
   searchFlowInstances,
   getFlowInstanceDetail,
   getTaskInstanceDetail,
-  stopFlowInstance
+  stopFlowInstance,
+  listBackfillFlows,
+  createBackfillJob,
+  updateBackfillJob,
+  deleteBackfillJob,
+  runBackfillJob,
+  searchBackfillJobs,
+  getBackfillJobDetail,
+  stopBackfillJob,
+  rerunBackfillJob
 ];
 var operations_default = commands4;
 
 // src/commands/te-dataops/repo/list-spaces.ts
-var toolName49 = "repo_list_spaces";
+var toolName58 = "repo_list_spaces";
 var listSpaces = {
   service: "dataops_repo",
   command: "+list_spaces",
   description: "List DataOps spaces accessible to the current user. Use this first when spaceCode is unknown. Returns createTime, spaceCode, and spaceDisplayName. No flags are required.",
   flags: [],
   risk: "read",
-  dryRun: (ctx) => buildDataopsApiDryRun(ctx, toolName49, {}),
+  dryRun: (ctx) => buildDataopsApiDryRun(ctx, toolName58, {}),
   execute: async (ctx) => {
-    return callDataopsApi(ctx, toolName49, {});
+    return callDataopsApi(ctx, toolName58, {});
   }
 };
 
@@ -1848,12 +2248,12 @@ var commands5 = [
 var repo_default = commands5;
 
 // src/commands/te-dataops/ide/cancel-sql-query.ts
-var toolName50 = "ide_cancel_sql_query";
+var toolName59 = "ide_cancel_sql_query";
 function optionalString4(ctx, name) {
   const value = ctx.str(name);
   return value === "" ? void 0 : value;
 }
-function buildArgs46(ctx) {
+function buildArgs49(ctx) {
   return {
     spaceCode: ctx.str("spaceCode"),
     downloadTaskId: ctx.num("downloadTaskId"),
@@ -1870,18 +2270,18 @@ var cancelSqlQuery = {
     { name: "requestId", type: "string", required: false, desc: "Optional request ID returned by +submit_sql_query, used only for trace display" }
   ],
   risk: "write",
-  dryRun: (ctx) => buildDataopsApiDryRun(ctx, toolName50, buildArgs46(ctx)),
-  execute: async (ctx) => callDataopsApi(ctx, toolName50, buildArgs46(ctx))
+  dryRun: (ctx) => buildDataopsApiDryRun(ctx, toolName59, buildArgs49(ctx)),
+  execute: async (ctx) => callDataopsApi(ctx, toolName59, buildArgs49(ctx))
 };
 
 // src/commands/te-dataops/ide/get-sql-query-status.ts
-var toolName51 = "ide_get_sql_query_status";
+var toolName60 = "ide_get_sql_query_status";
 var downloadPath = "/api/cli/dataops/v1/gaia/ide/sql-query-download";
 function optionalString5(ctx, name) {
   const value = ctx.str(name);
   return value === "" ? void 0 : value;
 }
-function buildArgs47(ctx) {
+function buildArgs50(ctx) {
   return {
     spaceCode: ctx.str("spaceCode"),
     downloadTaskId: ctx.num("downloadTaskId"),
@@ -1909,9 +2309,9 @@ var getSqlQueryStatus = {
     { name: "downloadTo", type: "string", required: false, desc: "Optional local file path. After SUCCESS, stream the result zip and replace this path only when the download completes; use a .zip suffix, for example ./result.zip." }
   ],
   risk: "read",
-  dryRun: (ctx) => buildDataopsApiDryRun(ctx, toolName51, buildArgs47(ctx)),
+  dryRun: (ctx) => buildDataopsApiDryRun(ctx, toolName60, buildArgs50(ctx)),
   execute: async (ctx) => {
-    const data = await callDataopsApi(ctx, toolName51, buildArgs47(ctx));
+    const data = await callDataopsApi(ctx, toolName60, buildArgs50(ctx));
     const downloadTo = optionalString5(ctx, "downloadTo");
     if (downloadTo && isDownloadReady(data)) {
       return { ...data, localFile: await downloadResult(ctx, data, downloadTo) };
@@ -1921,12 +2321,12 @@ var getSqlQueryStatus = {
 };
 
 // src/commands/te-dataops/ide/list-catalogs.ts
-var toolName52 = "ide_list_catalogs";
+var toolName61 = "ide_list_catalogs";
 function optionalString6(ctx, name) {
   const value = ctx.str(name);
   return value === "" ? void 0 : value;
 }
-function buildArgs48(ctx) {
+function buildArgs51(ctx) {
   return {
     spaceCode: ctx.str("spaceCode"),
     connType: optionalString6(ctx, "connType"),
@@ -1943,19 +2343,19 @@ var listCatalogs = {
     { name: "repoCode", type: "string", required: false, desc: "Optional repository code. Default te_etl" }
   ],
   risk: "read",
-  dryRun: (ctx) => buildDataopsApiDryRun(ctx, toolName52, buildArgs48(ctx)),
+  dryRun: (ctx) => buildDataopsApiDryRun(ctx, toolName61, buildArgs51(ctx)),
   execute: async (ctx) => {
-    return callDataopsApi(ctx, toolName52, buildArgs48(ctx));
+    return callDataopsApi(ctx, toolName61, buildArgs51(ctx));
   }
 };
 
 // src/commands/te-dataops/ide/get-schema-info.ts
-var toolName53 = "ide_get_schema_info";
+var toolName62 = "ide_get_schema_info";
 function optionalString7(ctx, name) {
   const value = ctx.str(name);
   return value === "" ? void 0 : value;
 }
-function buildArgs49(ctx) {
+function buildArgs52(ctx) {
   return {
     spaceCode: ctx.str("spaceCode"),
     connType: optionalString7(ctx, "connType"),
@@ -1987,14 +2387,14 @@ var getSchemaInfo = {
     { name: "schema", type: "string", required: true, desc: "Schema name" }
   ],
   risk: "read",
-  dryRun: (ctx) => buildDataopsApiDryRun(ctx, toolName53, buildArgs49(ctx)),
+  dryRun: (ctx) => buildDataopsApiDryRun(ctx, toolName62, buildArgs52(ctx)),
   execute: async (ctx) => {
-    return schemaStats(await callDataopsApi(ctx, toolName53, buildArgs49(ctx)));
+    return schemaStats(await callDataopsApi(ctx, toolName62, buildArgs52(ctx)));
   }
 };
 
 // src/commands/te-dataops/ide/get-table-detail.ts
-var toolName54 = "ide_get_table_detail";
+var toolName63 = "ide_get_table_detail";
 function optionalString8(ctx, name) {
   const value = ctx.str(name);
   return value === "" ? void 0 : value;
@@ -2007,7 +2407,7 @@ function optionalEntityType(ctx) {
   const value = optionalString8(ctx, "entityType");
   return value === void 0 ? void 0 : value.toUpperCase();
 }
-function buildArgs50(ctx) {
+function buildArgs53(ctx) {
   return {
     spaceCode: ctx.str("spaceCode"),
     connType: optionalString8(ctx, "connType"),
@@ -2042,19 +2442,19 @@ var getTableDetail2 = {
       throw new Error("entityType must be TABLE or VIEW");
     }
   },
-  dryRun: (ctx) => buildDataopsApiDryRun(ctx, toolName54, buildArgs50(ctx)),
+  dryRun: (ctx) => buildDataopsApiDryRun(ctx, toolName63, buildArgs53(ctx)),
   execute: async (ctx) => {
-    return callDataopsApi(ctx, toolName54, buildArgs50(ctx));
+    return callDataopsApi(ctx, toolName63, buildArgs53(ctx));
   }
 };
 
 // src/commands/te-dataops/ide/search-tables.ts
-var toolName55 = "ide_search_tables";
+var toolName64 = "ide_search_tables";
 function optionalString9(ctx, name) {
   const value = ctx.str(name);
   return value === "" ? void 0 : value;
 }
-function buildArgs51(ctx) {
+function buildArgs54(ctx) {
   return {
     spaceCode: ctx.str("spaceCode"),
     connType: optionalString9(ctx, "connType"),
@@ -2075,15 +2475,15 @@ var searchTables = {
     { name: "size", type: "number", required: false, desc: "Optional maximum results. Default 20" }
   ],
   risk: "read",
-  dryRun: (ctx) => buildDataopsApiDryRun(ctx, toolName55, buildArgs51(ctx)),
+  dryRun: (ctx) => buildDataopsApiDryRun(ctx, toolName64, buildArgs54(ctx)),
   execute: async (ctx) => {
-    return callDataopsApi(ctx, toolName55, buildArgs51(ctx));
+    return callDataopsApi(ctx, toolName64, buildArgs54(ctx));
   }
 };
 
 // src/commands/te-dataops/ide/list-repos.ts
-var toolName56 = "ide_list_repos";
-function buildArgs52(ctx) {
+var toolName65 = "ide_list_repos";
+function buildArgs55(ctx) {
   return {
     spaceCode: ctx.str("spaceCode")
   };
@@ -2096,14 +2496,14 @@ var listRepos = {
     { name: "spaceCode", type: "string", required: true, desc: "Space code" }
   ],
   risk: "read",
-  dryRun: (ctx) => buildDataopsApiDryRun(ctx, toolName56, buildArgs52(ctx)),
+  dryRun: (ctx) => buildDataopsApiDryRun(ctx, toolName65, buildArgs55(ctx)),
   execute: async (ctx) => {
-    return callDataopsApi(ctx, toolName56, buildArgs52(ctx));
+    return callDataopsApi(ctx, toolName65, buildArgs55(ctx));
   }
 };
 
 // src/commands/te-dataops/ide/list-tables.ts
-var toolName57 = "ide_list_tables";
+var toolName66 = "ide_list_tables";
 function optionalString10(ctx, name) {
   const value = ctx.str(name);
   return value === "" ? void 0 : value;
@@ -2112,7 +2512,7 @@ function optionalEntityType2(ctx) {
   const value = optionalString10(ctx, "entityType");
   return value === void 0 ? void 0 : value.toUpperCase();
 }
-function buildArgs53(ctx) {
+function buildArgs56(ctx) {
   return {
     spaceCode: ctx.str("spaceCode"),
     connType: optionalString10(ctx, "connType"),
@@ -2145,19 +2545,19 @@ var listTables = {
       throw new Error("entityType must be TABLE or VIEW");
     }
   },
-  dryRun: (ctx) => buildDataopsApiDryRun(ctx, toolName57, buildArgs53(ctx)),
+  dryRun: (ctx) => buildDataopsApiDryRun(ctx, toolName66, buildArgs56(ctx)),
   execute: async (ctx) => {
-    return callDataopsApi(ctx, toolName57, buildArgs53(ctx));
+    return callDataopsApi(ctx, toolName66, buildArgs56(ctx));
   }
 };
 
 // src/commands/te-dataops/ide/submit-sql-query.ts
-var toolName58 = "ide_submit_sql_query";
+var toolName67 = "ide_submit_sql_query";
 function optionalString11(ctx, name) {
   const value = ctx.str(name);
   return value === "" ? void 0 : value;
 }
-function buildArgs54(ctx) {
+function buildArgs57(ctx) {
   return {
     spaceCode: ctx.str("spaceCode"),
     repoCode: optionalString11(ctx, "repoCode"),
@@ -2176,8 +2576,8 @@ var submitSqlQuery = {
     { name: "engineType", type: "string", required: false, desc: "SQL execution engine. Defaults to TASK_ENGINE_TRINO. Optional: TASK_ENGINE_STARROCKS." }
   ],
   risk: "read",
-  dryRun: (ctx) => buildDataopsApiDryRun(ctx, toolName58, buildArgs54(ctx)),
-  execute: async (ctx) => callDataopsApi(ctx, toolName58, buildArgs54(ctx))
+  dryRun: (ctx) => buildDataopsApiDryRun(ctx, toolName67, buildArgs57(ctx)),
+  execute: async (ctx) => callDataopsApi(ctx, toolName67, buildArgs57(ctx))
 };
 
 // src/commands/te-dataops/ide/index.ts