@getmagical/cli 0.2.3 → 0.2.4

package/dist/index.js

@@ -7088,6 +7088,56 @@ var import_ts_essentials = __toESM(require_dist(), 1);
 // ../common/dist/src/stdlib/result.util.js
 import { z } from "zod";
 
+// ../common/dist/src/stdlib/error-temporal.js
+function isErrorLike(obj) {
+  return typeof obj === "object" && obj !== null && "name" in obj && "message" in obj && typeof obj.name === "string" && typeof obj.message === "string";
+}
+function isTemporalApplicationFailure(error) {
+  if (!isErrorLike(error)) {
+    return false;
+  }
+  return error.name === "ApplicationFailure" || !!error.stack?.startsWith("ApplicationFailure");
+}
+function isTemporalActivityFailure(error) {
+  if (!isErrorLike(error)) {
+    return false;
+  }
+  return error.name === "ActivityFailure" || error.message === "Activity task failed";
+}
+function isTemporalChildWorkflowFailure(error) {
+  if (!isErrorLike(error)) {
+    return false;
+  }
+  return error.name === "ChildWorkflowFailure" || error.message === "Child Workflow execution failed";
+}
+function isTemporalFailure(error) {
+  if (!isErrorLike(error)) {
+    return false;
+  }
+  return isTemporalApplicationFailure(error) || isTemporalActivityFailure(error) || isTemporalChildWorkflowFailure(error);
+}
+
+// ../common/dist/src/stdlib/error-serialization.js
+function getErrorMessage2(error, maxDepth = 10) {
+  if (error instanceof Error || isErrorLike2(error)) {
+    if (error.cause && maxDepth > 0) {
+      if (isTemporalFailure(error)) {
+        return getErrorMessage2(error.cause, maxDepth - 1);
+      }
+      return `${error.message}
+${getErrorMessage2(error.cause, maxDepth - 1)}`;
+    }
+    return error.message;
+  }
+  if (typeof error === "string" || typeof error === "number" || typeof error === "boolean" || error === void 0) {
+    return String(error);
+  }
+  return JSON.stringify(error);
+}
+function isErrorLike2(obj) {
+  return typeof obj === "object" && obj !== null && "name" in obj && "message" in obj && typeof obj.name === "string" && typeof obj.message === "string";
+}
+
 // ../common/dist/src/stdlib/error-user-facing.js
 var USER_FACING_STATUS_MESSAGES = /* @__PURE__ */ new Map([
   [400, "Bad Request"],
@@ -12206,6 +12256,16 @@ function replaceHandlebarsTemplates(value) {
   return value.replaceAll(HANDLEBARS_TEMPLATE_GLOBAL_REGEX, URL_TEMPLATE_PLACEHOLDER_VALUE);
 }
 
+// ../common/dist/src/stdlib/unsafe-object-key.util.js
+var UNSAFE_OBJECT_KEYS = /* @__PURE__ */ new Set([
+  "__proto__",
+  "constructor",
+  "prototype"
+]);
+function isUnsafeObjectKey(value) {
+  return UNSAFE_OBJECT_KEYS.has(value);
+}
+
 // ../common/dist/src/models/websocket/actions/scroll.js
 import { z as z9 } from "zod";
 var scrollDataSchema = z9.object({
@@ -13373,25 +13433,12 @@ function getIsKnowledgeBaseAssetPathAllowed(path7) {
   return isTopLevelAssetPath || isAutomationAssetPath || isAutomationAgentAssetPath;
 }
 
-// ../common/dist/src/utils/automation-variable-path.util.js
-var AUTOMATION_VARIABLE_PATH_SEGMENT_PATTERN = String.raw`[A-Za-z_][A-Za-z0-9_-]*`;
-var AUTOMATION_VARIABLE_PATH_PATTERN = String.raw`${AUTOMATION_VARIABLE_PATH_SEGMENT_PATTERN}(?:\.${AUTOMATION_VARIABLE_PATH_SEGMENT_PATTERN})*`;
-var DANGEROUS_AUTOMATION_VARIABLE_OBJECT_KEYS = /* @__PURE__ */ new Set([
-  "__proto__",
-  "constructor",
-  "prototype"
-]);
-var AUTOMATION_VARIABLE_PATH_SEGMENT_REGEX = new RegExp(`^${AUTOMATION_VARIABLE_PATH_SEGMENT_PATTERN}$`, "u");
-function isDangerousAutomationVariableObjectKey(value) {
-  return DANGEROUS_AUTOMATION_VARIABLE_OBJECT_KEYS.has(value);
-}
-
 // ../common/dist/src/utils/ponr-key-field-path.util.js
 var POINT_OF_NO_RETURN_KEY_FIELD_ROOTS = /* @__PURE__ */ new Set(["input", "store"]);
 function parsePointOfNoReturnKeyFieldPath(keyField) {
   const segments = keyField.split(".");
   const [root, ...pathSegments] = segments;
-  if (root === void 0 || !POINT_OF_NO_RETURN_KEY_FIELD_ROOTS.has(root) || pathSegments.length === 0 || pathSegments.some((segment) => segment.length === 0 || isDangerousAutomationVariableObjectKey(segment))) {
+  if (root === void 0 || !POINT_OF_NO_RETURN_KEY_FIELD_ROOTS.has(root) || pathSegments.length === 0 || pathSegments.some((segment) => segment.length === 0 || isUnsafeObjectKey(segment))) {
     return void 0;
   }
   return segments;
@@ -14133,6 +14180,67 @@ var automationRunStartConfigSchema = automationRunConfigBaseSchema.omit({
   networkTrafficCapture: networkTrafficCaptureSchema.nullable().optional().describe("Network traffic capture preference for this run. Omit to apply the implicit recording policy, pass null to explicitly disable capture, or pass a record/replay config to explicitly enable capture.")
 });
 
+// ../common/dist/src/utils/custom-instructions-command.util.js
+var MAX_CUSTOM_COMMAND_COUNT = 1;
+var MAX_CUSTOM_INSTRUCTIONS_LENGTH = 280;
+var STANDARD_COMMAND_NAMES = [
+  "callSpecializedAgent",
+  "checkpoint",
+  "click",
+  "clickFill",
+  "ifElse",
+  "loop",
+  "navigateTo",
+  "pressKeys",
+  "queueAgents",
+  "reportStop",
+  "somFilter"
+];
+function createInvalidValueError(message) {
+  const error = new Error(`INVALID_VALUE: ${message}`);
+  error.name = "INVALID_VALUE";
+  return error;
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getCustomInstructions(command) {
+  const commandArguments = command["arguments"];
+  if (!isRecord2(commandArguments)) {
+    return "";
+  }
+  const { instructions } = commandArguments;
+  return typeof instructions === "string" ? instructions.trim() : "";
+}
+function getMentionedStandardCommand(instructions) {
+  const normalizedInstructions = instructions.toLowerCase();
+  return STANDARD_COMMAND_NAMES.find((commandName) => normalizedInstructions.includes(commandName.toLowerCase())) ?? null;
+}
+function assertCustomInstructionsCommand({ commands, path: path7 }) {
+  const customCommands = commands.flatMap((command, commandIndex) => command["commandName"] === "custom" ? [{ command, path: `${path7}[${commandIndex.toString()}]` }] : []);
+  if (customCommands.length === 0) {
+    return;
+  }
+  if (customCommands.length > MAX_CUSTOM_COMMAND_COUNT) {
+    throw createInvalidValueError(`${path7} contains ${customCommands.length.toString()} custom commands. Use at most one short custom command per agent. Split policy, decision, outreach, and multi-step work into catalog commands or child agents instead.`);
+  }
+  const [customCommand] = customCommands;
+  if (!customCommand) {
+    return;
+  }
+  const instructions = getCustomInstructions(customCommand.command);
+  if (instructions.length === 0) {
+    throw createInvalidValueError(`${customCommand.path}.arguments.instructions must be a non-empty string for custom commands.`);
+  }
+  if (instructions.length > MAX_CUSTOM_INSTRUCTIONS_LENGTH) {
+    throw createInvalidValueError(`${customCommand.path}.arguments.instructions is ${instructions.length.toString()} characters. Custom commands must be short single-action instructions (max ${MAX_CUSTOM_INSTRUCTIONS_LENGTH.toString()} chars). Move policy/template/context text into description, inputSchema, or child agents, and express executable work with catalog commands.`);
+  }
+  const mentionedCommand = getMentionedStandardCommand(instructions);
+  if (mentionedCommand !== null) {
+    throw createInvalidValueError(`${customCommand.path}.arguments.instructions mentions "${mentionedCommand}". Use the "${mentionedCommand}" catalog command directly instead of wrapping it in custom prose.`);
+  }
+}
+
 // ../mcp-registry/src/operation-specs.ts
 import { z as z23 } from "zod";
 
@@ -14239,6 +14347,78 @@ function jsonOption({
   };
 }
 var jsonObjectSchema = z23.record(z23.string(), z23.unknown());
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function validateCustomInstructionsCommands({
+  commands,
+  ctx,
+  path: path7
+}) {
+  if (!Array.isArray(commands)) {
+    return;
+  }
+  const validationResult = fromThrowable(() => {
+    assertCustomInstructionsCommand({
+      commands: commands.map((command) => isRecord3(command) ? command : {}),
+      path: path7.join(".").replaceAll(/\.(?<index>\d+)/gu, "[$<index>]")
+    });
+  }, "invalid-custom-instructions-command");
+  if (isErr(validationResult)) {
+    ctx.addIssue({
+      code: "custom",
+      message: `${getErrorMessage2(validationResult.error.cause)} Run mgcl catalog commands to find the standard command for this work.`,
+      path: path7
+    });
+  }
+}
+var automationPatchOperationsSchema = z23.array(z23.unknown()).min(1).superRefine((operations, ctx) => {
+  for (const [operationIndex, operation] of operations.entries()) {
+    if (!isRecord3(operation)) {
+      continue;
+    }
+    const setCommands = operation["setAgentInstructionsCommands"];
+    if (!isRecord3(setCommands)) {
+      continue;
+    }
+    validateCustomInstructionsCommands({
+      commands: setCommands["instructionsCommands"],
+      ctx,
+      path: [
+        "operations",
+        operationIndex,
+        "setAgentInstructionsCommands",
+        "instructionsCommands"
+      ]
+    });
+  }
+});
+function automationInputSchema(agentKeys) {
+  return jsonObjectSchema.superRefine((input, ctx) => {
+    for (const agentKey of agentKeys) {
+      const agents = input[agentKey];
+      if (!Array.isArray(agents)) {
+        continue;
+      }
+      for (const [agentIndex, agent] of agents.entries()) {
+        if (!isRecord3(agent)) {
+          continue;
+        }
+        validateCustomInstructionsCommands({
+          commands: agent["instructionsCommands"],
+          ctx,
+          path: [agentKey, agentIndex, "instructionsCommands"]
+        });
+      }
+    }
+  });
+}
+var createAutomationInputSchema = automationInputSchema(["newAgents"]);
+var updateAutomationInputSchema = automationInputSchema([
+  "newAgents",
+  "updatedAgents"
+]);
+var COMMAND_CATALOG_HELP = "When authoring raw instructionsCommands, run mgcl catalog commands and prefer a standard command.";
 var agentBrowserProviderOptionsSelection = `            browserbase {
               advancedStealth
               contextId
@@ -14331,6 +14511,46 @@ var agentLimitationsSelection = `      limitations {
         allowedUrlRegexes
       }`;
 var operationSpecs = [
+  createOperationSpec({
+    operationName: "GetCaptureContext",
+    kind: "query",
+    inputSchema: z23.object({
+      automationId: z23.string().min(1).optional(),
+      recordingId: z23.string().min(1).optional()
+    }).refine(
+      ({ automationId, recordingId }) => [automationId, recordingId].some((value) => value !== void 0),
+      { message: "Provide --automation-id or --recording-id." }
+    ),
+    cli: {
+      name: "get-capture-context",
+      path: ["capture-context", "get"],
+      description: "Fetch raw browser events and screenshots from a Capture Mode recording.",
+      resultKey: "captureContext",
+      options: [
+        stringOption({
+          inputKey: "automationId",
+          flagName: "automation-id",
+          description: "Automation ID whose newest usable Capture Mode recording to fetch."
+        }),
+        stringOption({
+          inputKey: "recordingId",
+          flagName: "recording-id",
+          description: "Exact Capture Mode recording ID to fetch."
+        })
+      ]
+    },
+    mcp: { fileName: "captureContext.graphql" },
+    document: `# Fetch raw Capture Mode context with inline screenshots
+query GetCaptureContext($automationId: ID, $recordingId: ID) {
+  captureContext(
+    automationId: $automationId
+    recordingId: $recordingId
+  ) {
+    metadata
+    rawEvents
+  }
+}`
+  }),
   createOperationSpec({
     operationName: "GetAgents",
     kind: "query",
@@ -14921,6 +15141,57 @@ query GetAutomationRunIterations(
       screenshotMimeType
     }
   }
+}`
+  }),
+  createOperationSpec({
+    operationName: "InspectPausedAutomationStep",
+    kind: "query",
+    inputSchema: z23.object({
+      runId: z23.string().min(1)
+    }),
+    cli: {
+      name: "inspect-paused-automation-step",
+      path: ["automation-runs", "inspect-paused-step"],
+      description: "Inspect the latest persisted iteration for a paused manual-mode run.",
+      resultKey: "automationRunIterations",
+      options: [
+        stringOption({
+          inputKey: "runId",
+          flagName: "run-id",
+          description: "Automation run ID.",
+          required: true
+        })
+      ]
+    },
+    mcp: { fileName: "inspectPausedAutomationStep.graphql" },
+    document: `# Inspect the latest persisted iteration for a paused manual-mode run
+query InspectPausedAutomationStep($runId: ID!) {
+  automationRunIterations(
+    automationRunId: $runId
+    limit: 1
+    reverse: true
+  ) {
+    id
+    sequence
+    agentRunId
+    metadata
+    startedAt
+    finishedAt
+    totalDurationMs
+    llmResponseDurationMs
+    iterationContext
+    verificationResults
+    withMarksScreenshotUrl
+    withMarksMimeType
+    memories {
+      id
+      type
+      value
+      sequence
+      screenshotUrl
+      screenshotMimeType
+    }
+  }
 }`
   }),
   createOperationSpec({
@@ -15208,7 +15479,10 @@ query AnalyzeAutomationStoreMigration(
 query GetAvailableCommands($env: AvailableCommandsEnv!) {
   availableCommands(env: $env) {
     id
+    category
     description
+    template
+    whenToUse
     requiredTool
     inputSchema
   }
@@ -15796,7 +16070,7 @@ query GetAutomationWorkbenchSchemaSuggestions(
     operationName: "CreateAutomation",
     kind: "mutation",
     inputSchema: z23.object({
-      input: jsonObjectSchema
+      input: createAutomationInputSchema
     }),
     cli: {
       name: "create-automation",
@@ -15807,7 +16081,7 @@ query GetAutomationWorkbenchSchemaSuggestions(
         jsonOption({
           inputKey: "input",
           flagName: "input-json",
-          description: "CreateAutomationInput payload.",
+          description: `CreateAutomationInput payload. ${COMMAND_CATALOG_HELP}`,
           required: true
         })
       ]
@@ -15848,6 +16122,58 @@ mutation CreateAutomation($input: CreateAutomationInput!) {
 # reuse cached results.
 query GetGraphqlSchema {
   graphqlSchema
+}`
+  }),
+  createOperationSpec({
+    operationName: "ApproveAutomationStep",
+    kind: "mutation",
+    inputSchema: z23.object({
+      runId: z23.string().min(1)
+    }),
+    cli: {
+      name: "approve-automation-step",
+      path: ["automation-runs", "approve-step"],
+      description: "Approve the proposed step for a paused manual-mode run.",
+      resultKey: "approveAutomationStep",
+      options: [
+        stringOption({
+          inputKey: "runId",
+          flagName: "run-id",
+          description: "Automation run ID.",
+          required: true
+        })
+      ]
+    },
+    mcp: { fileName: "approveAutomationStep.graphql" },
+    document: `# Approve the proposed step for a paused manual-mode run
+mutation ApproveAutomationStep($runId: ID!) {
+  approveAutomationStep(automationRunId: $runId, retry: false)
+}`
+  }),
+  createOperationSpec({
+    operationName: "RetryAutomationStep",
+    kind: "mutation",
+    inputSchema: z23.object({
+      runId: z23.string().min(1)
+    }),
+    cli: {
+      name: "retry-automation-step",
+      path: ["automation-runs", "retry-step"],
+      description: "Retry the proposed step after saving a material change to its agent.",
+      resultKey: "approveAutomationStep",
+      options: [
+        stringOption({
+          inputKey: "runId",
+          flagName: "run-id",
+          description: "Automation run ID.",
+          required: true
+        })
+      ]
+    },
+    mcp: { fileName: "retryAutomationStep.graphql" },
+    document: `# Retry the proposed step after saving a material change to its agent
+mutation RetryAutomationStep($runId: ID!) {
+  approveAutomationStep(automationRunId: $runId, retry: true)
 }`
   }),
   createOperationSpec({
@@ -16092,7 +16418,7 @@ mutation StopAutomationRun($automationRunId: ID!) {
     inputSchema: z23.object({
       draftAutomationId: z23.string().min(1),
       expectedLastSavedAt: z23.string().optional(),
-      operations: z23.array(z23.unknown()).min(1)
+      operations: automationPatchOperationsSchema
     }),
     cli: {
       name: "preview-automation-patch",
@@ -16109,7 +16435,7 @@ mutation StopAutomationRun($automationRunId: ID!) {
         jsonOption({
           inputKey: "operations",
           flagName: "operations-json",
-          description: "Automation patch operations array using AutomationWorkbenchPatchOperationInput oneOf shape.",
+          description: `Automation patch operations array using AutomationWorkbenchPatchOperationInput oneOf shape. ${COMMAND_CATALOG_HELP}`,
           required: true
         })
       ]
@@ -16203,7 +16529,7 @@ mutation PreviewAutomationPatch(
     kind: "mutation",
     inputSchema: z23.object({
       draftAutomationId: z23.string().min(1),
-      operations: z23.array(z23.unknown()).min(1)
+      operations: automationPatchOperationsSchema
     }),
     cli: {
       name: "apply-automation-patch",
@@ -16220,7 +16546,7 @@ mutation PreviewAutomationPatch(
         jsonOption({
           inputKey: "operations",
           flagName: "operations-json",
-          description: "Automation patch operations array using AutomationWorkbenchPatchOperationInput oneOf shape.",
+          description: `Automation patch operations array using AutomationWorkbenchPatchOperationInput oneOf shape. ${COMMAND_CATALOG_HELP}`,
           required: true
         }),
         stringOption({
@@ -16321,7 +16647,7 @@ mutation ApplyAutomationPatch(
     kind: "mutation",
     inputSchema: z23.object({
       id: z23.string().min(1),
-      input: jsonObjectSchema
+      input: updateAutomationInputSchema
     }),
     cli: {
       name: "update-automation-by-id",
@@ -16338,7 +16664,7 @@ mutation ApplyAutomationPatch(
         jsonOption({
           inputKey: "input",
           flagName: "input-json",
-          description: "UpdateAutomationInput payload. Must include baseVersionId from a fresh read. Store schema writes are additive under config.storeSchema; use removeStoreSchemaPaths for explicit deletion or replaceStoreSchema for exact replacement.",
+          description: `UpdateAutomationInput payload. Must include baseVersionId from a fresh read. Store schema writes are additive under config.storeSchema; use removeStoreSchemaPaths for explicit deletion or replaceStoreSchema for exact replacement. ${COMMAND_CATALOG_HELP}`,
           required: true
         })
       ]
@@ -16456,7 +16782,7 @@ function getApiErrorDetail(responseBody) {
 function trimTrailingSlash(value) {
   return value.replace(/\/+$/u, "");
 }
-function isRecord2(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function decodeJwtPayload(token) {
@@ -16470,7 +16796,7 @@ function decodeJwtPayload(token) {
   if (isErr(payloadResult)) {
     return null;
   }
-  return isRecord2(payloadResult.value) ? payloadResult.value : null;
+  return isRecord4(payloadResult.value) ? payloadResult.value : null;
 }
 function isOttoAuthorizationToken(token) {
   return decodeJwtPayload(token)?.["iss"] === OTTO_AUTHORIZATION_ISSUER;
@@ -17669,7 +17995,7 @@ function createCliCommanderOption(optionSpec, helpGroup) {
   }
   return nextOption;
 }
-function isRecord3(value) {
+function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function resolveOrganizationBySelector({
@@ -17736,7 +18062,7 @@ function collectOperationVariables(operationSpec, options) {
       parsedVariables.error.issues[0]?.message ?? "Invalid command input."
     );
   }
-  if (!isRecord3(parsedVariables.data)) {
+  if (!isRecord5(parsedVariables.data)) {
     throw new CliError("Invalid command input.");
   }
   return parsedVariables.data;