skill-flow 1.3.1 → 1.3.4

package/dist/bridge-command.js

@@ -1,385 +1,443 @@
-import { buildBridgeResponse, isJsonObject, } from "@skill-flow/shared-types/protocol";
-export async function executeBridgeRequest(app, request) {
+// ../../packages/shared-types/dist/protocol.js
+var PROTOCOL_VERSION = "1.0";
+function buildBridgeResponse(args) {
+  return {
+    protocolVersion: PROTOCOL_VERSION,
+    command: args.command,
+    ...args.requestId ? { requestId: args.requestId } : {},
+    ok: args.ok,
+    ...args.data !== void 0 ? { data: args.data } : {},
+    warnings: args.warnings ?? [],
+    errors: args.errors ?? []
+  };
+}
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/bridge-command.ts
+async function executeBridgeRequest(app, request) {
+  try {
+    const previousCaller = process.env.SKILL_FLOW_CALLER;
+    process.env.SKILL_FLOW_CALLER = previousCaller?.trim() || "bridge";
     try {
-        const previousCaller = process.env.SKILL_FLOW_CALLER;
-        process.env.SKILL_FLOW_CALLER = previousCaller?.trim() || "bridge";
-        try {
-            switch (request.command) {
-                case "bootstrap": {
-                    const result = await app.bootstrapWorkspaceState();
-                    if (!result.ok) {
-                        return toFailureResponse(request, result.errors, result.warnings);
-                    }
-                    return buildResponseWithRequest({
-                        request,
-                        ok: true,
-                        data: sanitizeForJson(result.data),
-                        warnings: result.warnings.map((warning) => ({
-                            code: warning.code,
-                            message: warning.message,
-                        })),
-                    });
-                }
-                case "list": {
-                    const result = await app.listWorkflows();
-                    if (!result.ok) {
-                        return toFailureResponse(request, result.errors, result.warnings);
-                    }
-                    return buildResponseWithRequest({
-                        request,
-                        ok: true,
-                        data: sanitizeForJson(result.data),
-                        warnings: result.warnings.map((warning) => ({
-                            code: warning.code,
-                            message: warning.message,
-                        })),
-                    });
-                }
-                case "inspect": {
-                    const payload = expectObjectPayload(request.payload, "inspect");
-                    const sourceId = expectString(payload.sourceId, "sourceId", "inspect");
-                    const scope = expectProjectScope(payload.scope);
-                    const result = await app.inspectSource(sourceId, scope);
-                    if (!result.ok) {
-                        return toFailureResponse(request, result.errors, result.warnings);
-                    }
-                    return buildResponseWithRequest({
-                        request,
-                        ok: true,
-                        data: sanitizeForJson(result.data),
-                        warnings: result.warnings.map((warning) => ({
-                            code: warning.code,
-                            message: warning.message,
-                        })),
-                    });
-                }
-                case "inspect-enrichment": {
-                    const payload = expectObjectPayload(request.payload, "inspect-enrichment");
-                    const sourceId = expectString(payload.sourceId, "sourceId", "inspect-enrichment");
-                    const result = await app.inspectSourceEnrichment(sourceId);
-                    if (!result.ok) {
-                        return toFailureResponse(request, result.errors, result.warnings);
-                    }
-                    return buildResponseWithRequest({
-                        request,
-                        ok: true,
-                        data: sanitizeForJson(result.data),
-                        warnings: result.warnings.map((warning) => ({
-                            code: warning.code,
-                            message: warning.message,
-                        })),
-                    });
-                }
-                case "search-import-groups": {
-                    const payload = expectOptionalObject(request.payload, "search-import-groups");
-                    const query = payload ? expectOptionalString(payload.query, "query", "search-import-groups") : undefined;
-                    const result = await app.searchImportGroups(query ?? "");
-                    if (!result.ok) {
-                        return toFailureResponse(request, result.errors, result.warnings);
-                    }
-                    return buildResponseWithRequest({
-                        request,
-                        ok: true,
-                        data: sanitizeForJson(result.data),
-                        warnings: result.warnings.map((warning) => ({
-                            code: warning.code,
-                            message: warning.message,
-                        })),
-                    });
-                }
-                case "preview-import-source": {
-                    const payload = expectObjectPayload(request.payload, "preview-import-source");
-                    const locator = expectString(payload.locator, "locator", "preview-import-source");
-                    const result = await app.previewImportSource(locator);
-                    if (!result.ok) {
-                        return toFailureResponse(request, result.errors, result.warnings);
-                    }
-                    return buildResponseWithRequest({
-                        request,
-                        ok: true,
-                        data: sanitizeForJson(result.data),
-                        warnings: result.warnings.map((warning) => ({
-                            code: warning.code,
-                            message: warning.message,
-                        })),
-                    });
-                }
-                case "import-source": {
-                    const payload = expectObjectPayload(request.payload, "import-source");
-                    const locator = expectString(payload.locator, "locator", "import-source");
-                    const draft = expectOptionalImportDraft(payload.draft);
-                    const result = await app.importSource(locator, draft);
-                    if (!result.ok) {
-                        return toFailureResponse(request, result.errors, result.warnings);
-                    }
-                    return buildResponseWithRequest({
-                        request,
-                        ok: true,
-                        data: sanitizeForJson(result.data),
-                        warnings: result.warnings.map((warning) => ({
-                            code: warning.code,
-                            message: warning.message,
-                        })),
-                    });
-                }
-                case "toggle-pin": {
-                    const payload = expectObjectPayload(request.payload, "toggle-pin");
-                    const sourceId = expectString(payload.sourceId, "sourceId", "toggle-pin");
-                    const result = await app.togglePinnedSource(sourceId);
-                    if (!result.ok) {
-                        return toFailureResponse(request, result.errors, result.warnings);
-                    }
-                    return buildResponseWithRequest({
-                        request,
-                        ok: true,
-                        data: sanitizeForJson(result.data),
-                        warnings: result.warnings.map((warning) => ({
-                            code: warning.code,
-                            message: warning.message,
-                        })),
-                    });
-                }
-                case "doctor": {
-                    const result = await app.doctor();
-                    if (!result.ok) {
-                        return toFailureResponse(request, result.errors, result.warnings);
-                    }
-                    return buildResponseWithRequest({
-                        request,
-                        ok: true,
-                        data: sanitizeForJson(result.data),
-                        warnings: result.warnings.map((warning) => ({
-                            code: warning.code,
-                            message: warning.message,
-                        })),
-                    });
-                }
-                case "add": {
-                    const payload = expectObjectPayload(request.payload, "add");
-                    const locator = expectString(payload.locator, "locator", "add");
-                    const options = expectOptionalObject(payload.options, "add.options");
-                    const applyNow = payload.applyNow === true;
-                    const result = applyNow
-                        ? await app.addSource(locator, options)
-                        : await app.prepareAddSource(locator, options);
-                    if (!result.ok) {
-                        return toFailureResponse(request, result.errors, result.warnings);
-                    }
-                    return buildResponseWithRequest({
-                        request,
-                        ok: true,
-                        data: sanitizeForJson(result.data),
-                        warnings: result.warnings.map((warning) => ({
-                            code: warning.code,
-                            message: warning.message,
-                        })),
-                    });
-                }
-                case "apply": {
-                    const payload = expectObjectPayload(request.payload, "apply");
-                    const sourceId = expectString(payload.sourceId, "sourceId", "apply");
-                    const draft = expectDraftBinding(payload.draft);
-                    const scope = expectProjectScope(payload.scope);
-                    const result = await app.applyDraft(sourceId, draft, scope);
-                    if (!result.ok) {
-                        return toFailureResponse(request, result.errors, result.warnings);
-                    }
-                    return buildResponseWithRequest({
-                        request,
-                        ok: true,
-                        data: sanitizeForJson(result.data),
-                        warnings: result.warnings.map((warning) => ({
-                            code: warning.code,
-                            message: warning.message,
-                        })),
-                    });
-                }
-                case "update": {
-                    const payload = expectOptionalObject(request.payload, "update");
-                    const sourceIds = parseOptionalStringArray(payload?.sourceIds, "update.sourceIds");
-                    const result = await app.updateSources(sourceIds);
-                    if (!result.ok) {
-                        return toFailureResponse(request, result.errors, result.warnings);
-                    }
-                    return buildResponseWithRequest({
-                        request,
-                        ok: true,
-                        data: sanitizeForJson(result.data),
-                        warnings: result.warnings.map((warning) => ({
-                            code: warning.code,
-                            message: warning.message,
-                        })),
-                    });
-                }
-                case "uninstall": {
-                    const payload = expectObjectPayload(request.payload, "uninstall");
-                    const sourceIds = parseRequiredStringArray(payload.sourceIds, "uninstall.sourceIds");
-                    const result = await app.uninstall(sourceIds);
-                    if (!result.ok) {
-                        return toFailureResponse(request, result.errors, result.warnings);
-                    }
-                    return buildResponseWithRequest({
-                        request,
-                        ok: true,
-                        data: sanitizeForJson(result.data),
-                    });
-                }
-                default:
-                    return buildResponseWithRequest({
-                        request,
-                        ok: false,
-                        errors: [
-                            {
-                                code: "UNSUPPORTED_COMMAND",
-                                message: `Bridge command '${request.command}' is not supported.`,
-                            },
-                        ],
-                    });
-            }
+      switch (request.command) {
+        case "bootstrap": {
+          const result = await app.bootstrapWorkspaceState();
+          if (!result.ok) {
+            return toFailureResponse(request, result.errors, result.warnings);
+          }
+          return buildResponseWithRequest({
+            request,
+            ok: true,
+            data: sanitizeForJson(result.data),
+            warnings: result.warnings.map((warning) => ({
+              code: warning.code,
+              message: warning.message
+            }))
+          });
         }
-        finally {
-            if (previousCaller === undefined) {
-                delete process.env.SKILL_FLOW_CALLER;
-            }
-            else {
-                process.env.SKILL_FLOW_CALLER = previousCaller;
-            }
+        case "list": {
+          const result = await app.listWorkflows();
+          if (!result.ok) {
+            return toFailureResponse(request, result.errors, result.warnings);
+          }
+          return buildResponseWithRequest({
+            request,
+            ok: true,
+            data: sanitizeForJson(result.data),
+            warnings: result.warnings.map((warning) => ({
+              code: warning.code,
+              message: warning.message
+            }))
+          });
         }
-    }
-    catch (error) {
-        return buildResponseWithRequest({
+        case "inspect": {
+          const payload = expectObjectPayload(request.payload, "inspect");
+          const sourceId = expectString(payload.sourceId, "sourceId", "inspect");
+          const scope = expectProjectScope(payload.scope);
+          const result = await app.inspectSource(sourceId, scope);
+          if (!result.ok) {
+            return toFailureResponse(request, result.errors, result.warnings);
+          }
+          return buildResponseWithRequest({
+            request,
+            ok: true,
+            data: sanitizeForJson(result.data),
+            warnings: result.warnings.map((warning) => ({
+              code: warning.code,
+              message: warning.message
+            }))
+          });
+        }
+        case "inspect-enrichment": {
+          const payload = expectObjectPayload(request.payload, "inspect-enrichment");
+          const sourceId = expectString(payload.sourceId, "sourceId", "inspect-enrichment");
+          const result = await app.inspectSourceEnrichment(sourceId);
+          if (!result.ok) {
+            return toFailureResponse(request, result.errors, result.warnings);
+          }
+          return buildResponseWithRequest({
+            request,
+            ok: true,
+            data: sanitizeForJson(result.data),
+            warnings: result.warnings.map((warning) => ({
+              code: warning.code,
+              message: warning.message
+            }))
+          });
+        }
+        case "search-import-groups": {
+          const payload = expectOptionalObject(request.payload, "search-import-groups");
+          const query = payload ? expectOptionalString(payload.query, "query", "search-import-groups") : void 0;
+          const result = await app.searchImportGroups(query ?? "");
+          if (!result.ok) {
+            return toFailureResponse(request, result.errors, result.warnings);
+          }
+          return buildResponseWithRequest({
+            request,
+            ok: true,
+            data: sanitizeForJson(result.data),
+            warnings: result.warnings.map((warning) => ({
+              code: warning.code,
+              message: warning.message
+            }))
+          });
+        }
+        case "preview-import-source": {
+          const payload = expectObjectPayload(request.payload, "preview-import-source");
+          const locator = expectString(payload.locator, "locator", "preview-import-source");
+          const result = await app.previewImportSource(locator);
+          if (!result.ok) {
+            return toFailureResponse(request, result.errors, result.warnings);
+          }
+          return buildResponseWithRequest({
+            request,
+            ok: true,
+            data: sanitizeForJson(result.data),
+            warnings: result.warnings.map((warning) => ({
+              code: warning.code,
+              message: warning.message
+            }))
+          });
+        }
+        case "import-source": {
+          const payload = expectObjectPayload(request.payload, "import-source");
+          const locator = expectString(payload.locator, "locator", "import-source");
+          const draft = expectOptionalImportDraft(payload.draft);
+          const result = await app.importSource(locator, draft);
+          if (!result.ok) {
+            return toFailureResponse(request, result.errors, result.warnings);
+          }
+          return buildResponseWithRequest({
+            request,
+            ok: true,
+            data: sanitizeForJson(result.data),
+            warnings: result.warnings.map((warning) => ({
+              code: warning.code,
+              message: warning.message
+            }))
+          });
+        }
+        case "toggle-pin": {
+          const payload = expectObjectPayload(request.payload, "toggle-pin");
+          const sourceId = expectString(payload.sourceId, "sourceId", "toggle-pin");
+          const result = await app.togglePinnedSource(sourceId);
+          if (!result.ok) {
+            return toFailureResponse(request, result.errors, result.warnings);
+          }
+          return buildResponseWithRequest({
+            request,
+            ok: true,
+            data: sanitizeForJson(result.data),
+            warnings: result.warnings.map((warning) => ({
+              code: warning.code,
+              message: warning.message
+            }))
+          });
+        }
+        case "doctor": {
+          const result = await app.doctor();
+          if (!result.ok) {
+            return toFailureResponse(request, result.errors, result.warnings);
+          }
+          return buildResponseWithRequest({
+            request,
+            ok: true,
+            data: sanitizeForJson(result.data),
+            warnings: result.warnings.map((warning) => ({
+              code: warning.code,
+              message: warning.message
+            }))
+          });
+        }
+        case "add": {
+          const payload = expectObjectPayload(request.payload, "add");
+          const locator = expectString(payload.locator, "locator", "add");
+          const options = expectOptionalObject(payload.options, "add.options");
+          const applyNow = payload.applyNow === true;
+          const result = applyNow ? await app.addSource(locator, options) : await app.prepareAddSource(locator, options);
+          if (!result.ok) {
+            return toFailureResponse(request, result.errors, result.warnings);
+          }
+          return buildResponseWithRequest({
+            request,
+            ok: true,
+            data: sanitizeForJson(result.data),
+            warnings: result.warnings.map((warning) => ({
+              code: warning.code,
+              message: warning.message
+            }))
+          });
+        }
+        case "apply": {
+          const payload = expectObjectPayload(request.payload, "apply");
+          const sourceId = expectString(payload.sourceId, "sourceId", "apply");
+          const draft = expectDraftBinding(payload.draft);
+          const scope = expectProjectScope(payload.scope);
+          const result = await app.applyDraft(sourceId, draft, scope);
+          if (!result.ok) {
+            return toFailureResponse(request, result.errors, result.warnings);
+          }
+          return buildResponseWithRequest({
+            request,
+            ok: true,
+            data: sanitizeForJson(result.data),
+            warnings: result.warnings.map((warning) => ({
+              code: warning.code,
+              message: warning.message
+            }))
+          });
+        }
+        case "update": {
+          const payload = expectOptionalObject(request.payload, "update");
+          const sourceIds = parseOptionalStringArray(payload?.sourceIds, "update.sourceIds");
+          const result = await app.updateSources(sourceIds);
+          if (!result.ok) {
+            return toFailureResponse(request, result.errors, result.warnings);
+          }
+          return buildResponseWithRequest({
+            request,
+            ok: true,
+            data: sanitizeForJson(result.data),
+            warnings: result.warnings.map((warning) => ({
+              code: warning.code,
+              message: warning.message
+            }))
+          });
+        }
+        case "uninstall": {
+          const payload = expectObjectPayload(request.payload, "uninstall");
+          const sourceIds = parseRequiredStringArray(payload.sourceIds, "uninstall.sourceIds");
+          const result = await app.uninstall(sourceIds);
+          if (!result.ok) {
+            return toFailureResponse(request, result.errors, result.warnings);
+          }
+          return buildResponseWithRequest({
+            request,
+            ok: true,
+            data: sanitizeForJson(result.data)
+          });
+        }
+        case "save-settings": {
+          const payload = expectObjectPayload(request.payload, "save-settings");
+          const customTargets = expectCustomTargets(payload.customTargets);
+          const agentDisplayOrder = parseOptionalStringArray(
+            payload.agentDisplayOrder,
+            "save-settings.agentDisplayOrder"
+          ) ?? [];
+          const result = await app.saveSettings({ customTargets, agentDisplayOrder });
+          if (!result.ok) {
+            return toFailureResponse(request, result.errors, result.warnings);
+          }
+          return buildResponseWithRequest({
+            request,
+            ok: true,
+            data: sanitizeForJson(result.data),
+            warnings: result.warnings.map((warning) => ({
+              code: warning.code,
+              message: warning.message
+            }))
+          });
+        }
+        default:
+          return buildResponseWithRequest({
             request,
             ok: false,
             errors: [
-                {
-                    code: "BRIDGE_REQUEST_INVALID",
-                    message: error instanceof Error ? error.message : String(error),
-                },
-            ],
-        });
+              {
+                code: "UNSUPPORTED_COMMAND",
+                message: `Bridge command '${request.command}' is not supported.`
+              }
+            ]
+          });
+      }
+    } finally {
+      if (previousCaller === void 0) {
+        delete process.env.SKILL_FLOW_CALLER;
+      } else {
+        process.env.SKILL_FLOW_CALLER = previousCaller;
+      }
     }
-}
-function toFailureResponse(request, errors, warnings) {
+  } catch (error) {
     return buildResponseWithRequest({
-        request,
-        ok: false,
-        warnings: warnings.map((warning) => ({ code: warning.code, message: warning.message })),
-        errors: errors.map((error) => ({ code: error.code, message: error.message })),
+      request,
+      ok: false,
+      errors: [
+        {
+          code: "BRIDGE_REQUEST_INVALID",
+          message: error instanceof Error ? error.message : String(error)
+        }
+      ]
     });
+  }
+}
+function toFailureResponse(request, errors, warnings) {
+  return buildResponseWithRequest({
+    request,
+    ok: false,
+    warnings: warnings.map((warning) => ({ code: warning.code, message: warning.message })),
+    errors: errors.map((error) => ({ code: error.code, message: error.message }))
+  });
 }
 function buildResponseWithRequest(args) {
-    return buildBridgeResponse({
-        command: args.request.command,
-        ...(args.request.requestId ? { requestId: args.request.requestId } : {}),
-        ok: args.ok,
-        ...(args.data !== undefined ? { data: args.data } : {}),
-        ...(args.warnings ? { warnings: args.warnings } : {}),
-        ...(args.errors ? { errors: args.errors } : {}),
-    });
+  return buildBridgeResponse({
+    command: args.request.command,
+    ...args.request.requestId ? { requestId: args.request.requestId } : {},
+    ok: args.ok,
+    ...args.data !== void 0 ? { data: args.data } : {},
+    ...args.warnings ? { warnings: args.warnings } : {},
+    ...args.errors ? { errors: args.errors } : {}
+  });
 }
 function expectObjectPayload(payload, command) {
-    if (!isJsonObject(payload)) {
-        throw new Error(`Bridge command '${command}' requires an object payload.`);
-    }
-    return payload;
+  if (!isJsonObject(payload)) {
+    throw new Error(`Bridge command '${command}' requires an object payload.`);
+  }
+  return payload;
 }
 function expectOptionalObject(value, field) {
-    if (value === undefined) {
-        return undefined;
-    }
-    if (!isJsonObject(value)) {
-        throw new Error(`Field '${field}' must be a JSON object when provided.`);
-    }
-    return value;
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!isJsonObject(value)) {
+    throw new Error(`Field '${field}' must be a JSON object when provided.`);
+  }
+  return value;
 }
 function expectString(value, field, command) {
-    if (typeof value !== "string" || value.length === 0) {
-        throw new Error(`Bridge command '${command}' requires a non-empty string field '${field}'.`);
-    }
-    return value;
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`Bridge command '${command}' requires a non-empty string field '${field}'.`);
+  }
+  return value;
 }
 function expectOptionalString(value, field, command) {
-    if (value === undefined) {
-        return undefined;
-    }
-    if (typeof value !== "string") {
-        throw new Error(`Bridge command '${command}' requires string field '${field}' when provided.`);
-    }
-    return value;
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    throw new Error(`Bridge command '${command}' requires string field '${field}' when provided.`);
+  }
+  return value;
 }
 function parseRequiredStringArray(value, field) {
-    const parsed = parseOptionalStringArray(value, field);
-    if (!parsed || parsed.length === 0) {
-        throw new Error(`Field '${field}' must be a non-empty string array.`);
-    }
-    return parsed;
+  const parsed = parseOptionalStringArray(value, field);
+  if (!parsed || parsed.length === 0) {
+    throw new Error(`Field '${field}' must be a non-empty string array.`);
+  }
+  return parsed;
 }
 function parseOptionalStringArray(value, field) {
-    if (value === undefined) {
-        return undefined;
-    }
-    if (!Array.isArray(value) || value.some((item) => typeof item !== "string" || item.length === 0)) {
-        throw new Error(`Field '${field}' must be a string array.`);
-    }
-    return value;
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string" || item.length === 0)) {
+    throw new Error(`Field '${field}' must be a string array.`);
+  }
+  return value;
 }
 function expectDraftBinding(value) {
-    if (!isJsonObject(value)) {
-        throw new Error("Bridge command 'apply' requires object field 'draft'.");
-    }
-    const selectedLeafIds = parseOptionalStringArray(value.selectedLeafIds, "draft.selectedLeafIds");
-    if (!selectedLeafIds) {
-        throw new Error("Field 'draft.selectedLeafIds' must be a string array.");
-    }
-    const enabledTargets = parseOptionalStringArray(value.enabledTargets, "draft.enabledTargets") ?? [];
-    return {
-        selectedLeafIds,
-        enabledTargets: enabledTargets,
-    };
+  if (!isJsonObject(value)) {
+    throw new Error("Bridge command 'apply' requires object field 'draft'.");
+  }
+  const selectedLeafIds = parseOptionalStringArray(value.selectedLeafIds, "draft.selectedLeafIds");
+  if (!selectedLeafIds) {
+    throw new Error("Field 'draft.selectedLeafIds' must be a string array.");
+  }
+  const enabledTargets = parseOptionalStringArray(value.enabledTargets, "draft.enabledTargets") ?? [];
+  return {
+    selectedLeafIds,
+    enabledTargets
+  };
 }
 function expectOptionalImportDraft(value) {
-    if (value === undefined) {
-        return undefined;
-    }
-    if (!isJsonObject(value)) {
-        throw new Error("Field 'draft' must be a JSON object when provided.");
-    }
-    const selectedSkillIds = parseOptionalStringArray(value.selectedSkillIds, "draft.selectedSkillIds");
-    if (!selectedSkillIds) {
-        throw new Error("Field 'draft.selectedSkillIds' must be a string array.");
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!isJsonObject(value)) {
+    throw new Error("Field 'draft' must be a JSON object when provided.");
+  }
+  const selectedSkillIds = parseOptionalStringArray(value.selectedSkillIds, "draft.selectedSkillIds");
+  if (!selectedSkillIds) {
+    throw new Error("Field 'draft.selectedSkillIds' must be a string array.");
+  }
+  const enabledTargets = parseOptionalStringArray(value.enabledTargets, "draft.enabledTargets") ?? [];
+  return {
+    selectedSkillIds,
+    enabledTargets
+  };
+}
+function expectCustomTargets(value) {
+  if (!Array.isArray(value)) {
+    throw new Error("Field 'customTargets' must be an array.");
+  }
+  return value.map((entry, index) => {
+    if (!isJsonObject(entry)) {
+      throw new Error(`Field 'customTargets[${index}]' must be an object.`);
     }
-    const enabledTargets = parseOptionalStringArray(value.enabledTargets, "draft.enabledTargets") ?? [];
     return {
-        selectedSkillIds,
-        enabledTargets: enabledTargets,
+      id: expectString(entry.id, `customTargets[${index}].id`, "save-settings"),
+      name: expectString(entry.name, `customTargets[${index}].name`, "save-settings"),
+      globalPath: expectString(entry.globalPath, `customTargets[${index}].globalPath`, "save-settings"),
+      projectPathTemplate: expectString(entry.projectPathTemplate, `customTargets[${index}].projectPathTemplate`, "save-settings"),
+      strategy: expectString(entry.strategy, `customTargets[${index}].strategy`, "save-settings"),
+      createdAt: expectString(entry.createdAt, `customTargets[${index}].createdAt`, "save-settings"),
+      updatedAt: expectString(entry.updatedAt, `customTargets[${index}].updatedAt`, "save-settings")
     };
+  });
 }
 function expectProjectScope(value) {
-    if (value === undefined) {
-        return { kind: "global" };
-    }
-    if (!isJsonObject(value) || typeof value.kind !== "string") {
-        throw new Error("Field 'scope' must be a JSON object with kind 'global' or kind 'project' and a non-empty string 'projectId'.");
-    }
-    if (value.kind === "global") {
-        return { kind: "global" };
+  if (value === void 0) {
+    return { kind: "global" };
+  }
+  if (!isJsonObject(value) || typeof value.kind !== "string") {
+    throw new Error(
+      "Field 'scope' must be a JSON object with kind 'global' or kind 'project' and a non-empty string 'projectId'."
+    );
+  }
+  if (value.kind === "global") {
+    return { kind: "global" };
+  }
+  if (value.kind === "project") {
+    if (typeof value.projectId === "string" && value.projectId.length > 0) {
+      return { kind: "project", projectId: value.projectId };
     }
-    if (value.kind === "project") {
-        if (typeof value.projectId === "string" && value.projectId.length > 0) {
-            return { kind: "project", projectId: value.projectId };
-        }
-        throw new Error("Field 'scope.projectId' must be a non-empty string when scope.kind is 'project'.");
-    }
-    throw new Error("Field 'scope.kind' must be either 'global' or 'project'.");
+    throw new Error("Field 'scope.projectId' must be a non-empty string when scope.kind is 'project'.");
+  }
+  throw new Error("Field 'scope.kind' must be either 'global' or 'project'.");
 }
 function sanitizeForJson(value) {
-    return JSON.parse(JSON.stringify(value));
+  return JSON.parse(JSON.stringify(value));
 }
-export function buildBridgeParseFailure(command, failure) {
-    return buildBridgeResponse({
-        command: command,
-        ok: false,
-        errors: [failure],
-    });
+function buildBridgeParseFailure(command, failure) {
+  return buildBridgeResponse({
+    command,
+    ok: false,
+    errors: [failure]
+  });
 }
-//# sourceMappingURL=bridge-command.js.map
+export {
+  buildBridgeParseFailure,
+  executeBridgeRequest
+};
+//# sourceMappingURL=bridge-command.js.map