lody 0.66.0 → 0.67.0

package/dist/chunks/baseline-config-BPa_f3S0.js

@@ -0,0 +1,283 @@
+import { createRequire } from "module";
+createRequire(import.meta.url);
+var MODE_CONFIG_ID = "mode";
+var AgentMode = class _AgentMode {
+  id;
+  name;
+  description;
+  approvalPolicy;
+  sandboxPolicy;
+  sandboxMode;
+  constructor(id, name, description, approval, sandbox, sandboxMode) {
+    this.id = id;
+    this.name = name;
+    this.description = description;
+    this.approvalPolicy = approval;
+    this.sandboxPolicy = sandbox;
+    this.sandboxMode = sandboxMode;
+  }
+  static ReadOnly = new _AgentMode(
+    "read-only",
+    "Read-only",
+    "Requires approval to edit files and run commands.",
+    "on-request",
+    {
+      "type": "readOnly",
+      "networkAccess": false
+    },
+    "read-only"
+  );
+  static Agent = new _AgentMode(
+    "agent",
+    "Agent",
+    "Read and edit files, and run commands.",
+    "on-request",
+    {
+      type: "workspaceWrite",
+      writableRoots: [],
+      networkAccess: false,
+      excludeTmpdirEnvVar: false,
+      excludeSlashTmp: false
+    },
+    "workspace-write"
+  );
+  static AgentFullAccess = new _AgentMode(
+    "agent-full-access",
+    "Agent (full access)",
+    "Codex can edit files outside this workspace and run commands with network access. Exercise caution when using.",
+    "never",
+    { "type": "dangerFullAccess" },
+    "danger-full-access"
+  );
+  static DEFAULT_AGENT_MODE = _AgentMode.Agent;
+  toSessionMode() {
+    return {
+      id: this.id,
+      name: this.name,
+      description: this.description
+    };
+  }
+  toSessionModeState() {
+    return {
+      availableModes: _AgentMode.all().map((mode) => mode.toSessionMode()),
+      currentModeId: this.id
+    };
+  }
+  toConfigOption() {
+    return {
+      id: MODE_CONFIG_ID,
+      name: "Mode",
+      description: "Approval and sandboxing preset for the session",
+      category: "mode",
+      type: "select",
+      currentValue: this.id,
+      options: _AgentMode.all().map((mode) => ({
+        value: mode.id,
+        name: mode.name,
+        description: mode.description
+      }))
+    };
+  }
+  static all() {
+    return [_AgentMode.ReadOnly, _AgentMode.Agent, _AgentMode.AgentFullAccess];
+  }
+  static find(modeId) {
+    const match = _AgentMode.all().find((m) => m.id === modeId);
+    return match ?? null;
+  }
+  static getInitialAgentMode() {
+    const predefinedAgentMode = process.env["INITIAL_AGENT_MODE"];
+    if (predefinedAgentMode) {
+      return _AgentMode.find(predefinedAgentMode) ?? _AgentMode.DEFAULT_AGENT_MODE;
+    } else {
+      return _AgentMode.DEFAULT_AGENT_MODE;
+    }
+  }
+};
+var FAST_MODE_CONFIG_ID = "fast-mode";
+var FAST_MODE_ON = "on";
+var FAST_MODE_OFF = "off";
+var FAST_MODE_DESCRIPTION = "1.5x speed, increased usage";
+function createFastModeConfigOption(fastModeEnabled) {
+  return {
+    id: FAST_MODE_CONFIG_ID,
+    name: "Fast mode",
+    description: FAST_MODE_DESCRIPTION,
+    category: FAST_MODE_CONFIG_ID,
+    type: "select",
+    currentValue: fastModeEnabled ? FAST_MODE_ON : FAST_MODE_OFF,
+    options: [
+      {
+        value: FAST_MODE_OFF,
+        name: "Off",
+        description: "Default speed, normal usage"
+      },
+      {
+        value: FAST_MODE_ON,
+        name: "On",
+        description: FAST_MODE_DESCRIPTION
+      }
+    ]
+  };
+}
+var MODEL_CONFIG_ID = "model";
+var REASONING_EFFORT_CONFIG_ID = "reasoning_effort";
+function createModelConfigOption(availableModels, currentBaseModelId) {
+  return {
+    id: MODEL_CONFIG_ID,
+    name: "Model",
+    description: "Model Codex uses for the session",
+    category: "model",
+    type: "select",
+    currentValue: currentBaseModelId,
+    options: availableModels.map((model) => ({
+      value: model.id,
+      name: model.displayName,
+      description: model.description
+    }))
+  };
+}
+function createReasoningEffortConfigOption(supportedReasoningEfforts, currentEffort) {
+  return {
+    id: REASONING_EFFORT_CONFIG_ID,
+    name: "Reasoning effort",
+    description: "How much reasoning effort the model should use",
+    category: "thought_level",
+    type: "select",
+    currentValue: currentEffort,
+    options: supportedReasoningEfforts.map((option) => ({
+      value: option.reasoningEffort,
+      name: option.reasoningEffort,
+      description: option.description
+    }))
+  };
+}
+var PLAN_MODE_CONFIG_ID = "plan-mode";
+var PLAN_MODE_ON = "on";
+var PLAN_MODE_OFF = "off";
+var PLAN_MODE_DESCRIPTION = "Plan without modifying files; switch off to implement the approved plan";
+function createPlanModeConfigOption(planModeEnabled) {
+  return {
+    id: PLAN_MODE_CONFIG_ID,
+    name: "Plan mode",
+    description: PLAN_MODE_DESCRIPTION,
+    category: PLAN_MODE_CONFIG_ID,
+    type: "select",
+    currentValue: planModeEnabled ? PLAN_MODE_ON : PLAN_MODE_OFF,
+    options: [
+      {
+        value: PLAN_MODE_OFF,
+        name: "Off",
+        description: "Implement changes normally"
+      },
+      {
+        value: PLAN_MODE_ON,
+        name: "On",
+        description: PLAN_MODE_DESCRIPTION
+      }
+    ]
+  };
+}
+var BASELINE_REASONING_EFFORTS = [
+  { reasoningEffort: "low", description: "Fastest responses" },
+  { reasoningEffort: "medium", description: "Balanced reasoning" },
+  { reasoningEffort: "high", description: "More reasoning for difficult tasks" },
+  { reasoningEffort: "xhigh", description: "Extra reasoning for complex tasks" }
+];
+var BASELINE_MODELS = [
+  {
+    id: "gpt-5.5",
+    model: "gpt-5.5",
+    upgrade: null,
+    upgradeInfo: null,
+    availabilityNux: null,
+    displayName: "gpt-5.5",
+    description: "Latest frontier Codex model",
+    hidden: false,
+    supportedReasoningEfforts: BASELINE_REASONING_EFFORTS,
+    defaultReasoningEffort: "medium",
+    inputModalities: ["text", "image"],
+    supportsPersonality: false,
+    additionalSpeedTiers: ["fast"],
+    serviceTiers: [],
+    defaultServiceTier: null,
+    isDefault: true
+  },
+  {
+    id: "gpt-5.4",
+    model: "gpt-5.4",
+    upgrade: null,
+    upgradeInfo: null,
+    availabilityNux: null,
+    displayName: "gpt-5.4",
+    description: "Frontier Codex model",
+    hidden: false,
+    supportedReasoningEfforts: BASELINE_REASONING_EFFORTS,
+    defaultReasoningEffort: "medium",
+    inputModalities: ["text", "image"],
+    supportsPersonality: false,
+    additionalSpeedTiers: ["fast"],
+    serviceTiers: [],
+    defaultServiceTier: null,
+    isDefault: false
+  },
+  {
+    id: "gpt-5.4-mini",
+    model: "gpt-5.4-mini",
+    upgrade: null,
+    upgradeInfo: null,
+    availabilityNux: null,
+    displayName: "gpt-5.4-mini",
+    description: "Smaller, faster Codex model",
+    hidden: false,
+    supportedReasoningEfforts: BASELINE_REASONING_EFFORTS,
+    defaultReasoningEffort: "medium",
+    inputModalities: ["text", "image"],
+    supportsPersonality: false,
+    additionalSpeedTiers: ["fast"],
+    serviceTiers: [],
+    defaultServiceTier: null,
+    isDefault: false
+  }
+];
+function getDefaultBaselineModel() {
+  const model = BASELINE_MODELS.find((candidate) => candidate.isDefault) ?? BASELINE_MODELS[0];
+  if (!model) {
+    throw new Error("Codex baseline config requires at least one model");
+  }
+  return model;
+}
+function getCodexBaselineConfig() {
+  const defaultModel = getDefaultBaselineModel();
+  return {
+    modes: AgentMode.all().map((mode) => {
+      const sessionMode = mode.toSessionMode();
+      const result = {
+        id: sessionMode.id,
+        name: sessionMode.name
+      };
+      if (sessionMode.description !== null && sessionMode.description !== void 0) {
+        result.description = sessionMode.description;
+      }
+      return result;
+    }),
+    models: BASELINE_MODELS.map((model) => ({
+      modelId: model.id,
+      name: model.displayName,
+      description: model.description
+    })),
+    configOptions: [
+      AgentMode.DEFAULT_AGENT_MODE.toConfigOption(),
+      createModelConfigOption(BASELINE_MODELS, defaultModel.id),
+      createReasoningEffortConfigOption(
+        defaultModel.supportedReasoningEfforts,
+        defaultModel.defaultReasoningEffort
+      ),
+      createFastModeConfigOption(false),
+      createPlanModeConfigOption(false)
+    ]
+  };
+}
+export {
+  getCodexBaselineConfig
+};

package/dist/chunks/baseline-config-CcYq1mUH.js

@@ -0,0 +1,245 @@
+const CLAUDE_BASELINE_MODEL_INFOS = [
+  {
+    value: "default",
+    displayName: "Default",
+    description: "Claude Code default model",
+    supportsEffort: true,
+    supportedEffortLevels: ["low", "medium", "high"],
+    supportsAutoMode: true
+  },
+  {
+    value: "opus",
+    displayName: "Opus",
+    description: "Claude Opus",
+    supportsEffort: true,
+    supportedEffortLevels: ["low", "medium", "high"],
+    supportsAutoMode: true
+  },
+  {
+    value: "sonnet",
+    displayName: "Sonnet",
+    description: "Claude Sonnet",
+    supportsEffort: true,
+    supportedEffortLevels: ["low", "medium", "high"],
+    supportsAutoMode: true,
+    supportsFastMode: true
+  },
+  {
+    value: "haiku",
+    displayName: "Haiku",
+    description: "Claude Haiku",
+    supportsEffort: true,
+    supportedEffortLevels: ["low", "medium", "high"],
+    supportsFastMode: true
+  }
+];
+const BUILTIN_AGENT_NAMES = /* @__PURE__ */ new Set([
+  "claude",
+  "general-purpose",
+  "Explore",
+  "Plan",
+  "statusline-setup"
+]);
+const DEFAULT_AGENT_ID = "default";
+const MODE_CONFIG_ID = "mode";
+const MODEL_CONFIG_ID = "model";
+const EFFORT_CONFIG_ID = "effort";
+const AGENT_CONFIG_ID = "agent";
+const FAST_MODE_CONFIG_ID = "fast";
+const FAST_MODE_ON = "on";
+const FAST_MODE_OFF = "off";
+const FAST_MODE_DESCRIPTION = "Faster responses on supported models";
+function buildAvailableModes(modelInfo, options = {}) {
+  const modes = [];
+  if (modelInfo?.supportsAutoMode === true) {
+    modes.push({
+      id: "auto",
+      name: "Auto",
+      description: "Use a model classifier to approve/deny permission prompts"
+    });
+  }
+  modes.push({
+    id: "default",
+    name: "Default",
+    description: "Standard behavior, prompts for dangerous operations"
+  }, {
+    id: "acceptEdits",
+    name: "Accept Edits",
+    description: "Auto-accept file edit operations"
+  }, {
+    id: "plan",
+    name: "Plan Mode",
+    description: "Planning mode, no actual tool execution"
+  }, {
+    id: "dontAsk",
+    name: "Don't Ask",
+    description: "Don't prompt for permissions, deny if not pre-approved"
+  });
+  if (options.allowBypass === true) {
+    modes.push({
+      id: "bypassPermissions",
+      name: "Bypass Permissions",
+      description: "Bypass all permission checks"
+    });
+  }
+  return modes;
+}
+function fastModeStateEnabled(state) {
+  return state !== "off";
+}
+function clientSupportsBooleanConfigOptions(clientCapabilities) {
+  return clientCapabilities?.session?.configOptions?.boolean != null;
+}
+function createFastModeConfigOption(enabled, useBooleanOption) {
+  const base = {
+    id: FAST_MODE_CONFIG_ID,
+    name: "Fast mode",
+    description: FAST_MODE_DESCRIPTION,
+    category: "model_config"
+  };
+  if (useBooleanOption) {
+    return { ...base, type: "boolean", currentValue: enabled };
+  }
+  return {
+    ...base,
+    type: "select",
+    currentValue: enabled ? FAST_MODE_ON : FAST_MODE_OFF,
+    options: [
+      { value: FAST_MODE_ON, name: "On" },
+      { value: FAST_MODE_OFF, name: "Off" }
+    ]
+  };
+}
+function resolveFastModeEnabled(params) {
+  const value = params.value;
+  if (typeof value === "boolean") {
+    return value;
+  }
+  if (value === FAST_MODE_ON) {
+    return true;
+  }
+  if (value === FAST_MODE_OFF) {
+    return false;
+  }
+  throw new Error(`Invalid value for config option ${FAST_MODE_CONFIG_ID}: ${value}`);
+}
+function buildConfigOptions(modes, models, modelInfos, currentEffortLevel, agents = [], currentAgent = DEFAULT_AGENT_ID, fastMode) {
+  const options = [
+    {
+      id: MODE_CONFIG_ID,
+      name: "Mode",
+      description: "Session permission mode",
+      category: "mode",
+      type: "select",
+      currentValue: modes.currentModeId,
+      options: modes.availableModes.map((mode) => ({
+        value: mode.id,
+        name: mode.name,
+        description: mode.description
+      }))
+    },
+    {
+      id: MODEL_CONFIG_ID,
+      name: "Model",
+      description: "AI model to use",
+      category: "model",
+      type: "select",
+      currentValue: models.currentModelId,
+      options: models.availableModels.map((model) => ({
+        value: model.modelId,
+        name: model.name,
+        description: model.description ?? void 0
+      }))
+    }
+  ];
+  const currentModelInfo = modelInfos.find((model) => model.value === models.currentModelId);
+  const supportedLevels = currentModelInfo?.supportsEffort ? currentModelInfo.supportedEffortLevels ?? [] : [];
+  if (supportedLevels.length > 0) {
+    const effortOptions = [
+      { value: "default", name: "Default" },
+      ...supportedLevels.map((level) => ({
+        value: level,
+        name: level.split(/[_-]/).map((part) => part ? part.charAt(0).toUpperCase() + part.slice(1) : part).join(" ")
+      }))
+    ];
+    const includes = (level) => level === "default" || supportedLevels.includes(level);
+    const validEffort = currentEffortLevel && includes(currentEffortLevel) ? currentEffortLevel : "default";
+    options.push({
+      id: EFFORT_CONFIG_ID,
+      name: "Effort",
+      description: "Available effort levels for this model",
+      category: "thought_level",
+      type: "select",
+      currentValue: validEffort,
+      options: effortOptions
+    });
+  }
+  if (fastMode?.supported) {
+    options.push(createFastModeConfigOption(fastMode.enabled, fastMode.useBooleanOption));
+  }
+  if (agents.length > 0) {
+    options.push({
+      id: AGENT_CONFIG_ID,
+      name: "Agent",
+      description: "Main-thread agent persona",
+      type: "select",
+      currentValue: currentAgent,
+      options: [
+        { value: DEFAULT_AGENT_ID, name: "Default", description: "Standard Claude Code agent" },
+        ...agents.map((agent) => ({
+          value: agent.name,
+          name: agent.name,
+          description: agent.description || void 0
+        }))
+      ]
+    });
+  }
+  return options;
+}
+function getClaudeBaselineConfig() {
+  const currentModelId = "default";
+  const currentModelInfo = CLAUDE_BASELINE_MODEL_INFOS.find((model) => model.value === currentModelId);
+  const modes = {
+    currentModeId: "default",
+    availableModes: buildAvailableModes(currentModelInfo)
+  };
+  const models = {
+    currentModelId,
+    availableModels: CLAUDE_BASELINE_MODEL_INFOS.map((model) => ({
+      modelId: model.value,
+      name: model.displayName,
+      description: model.description
+    }))
+  };
+  return {
+    modes: modes.availableModes.map((mode) => ({
+      id: mode.id,
+      name: mode.name,
+      description: mode.description ?? void 0
+    })),
+    models: models.availableModels.map((model) => ({
+      modelId: model.modelId,
+      name: model.name,
+      description: model.description
+    })),
+    configOptions: buildConfigOptions(modes, models, CLAUDE_BASELINE_MODEL_INFOS, void 0, [], "default", void 0)
+  };
+}
+export {
+  AGENT_CONFIG_ID,
+  BUILTIN_AGENT_NAMES,
+  DEFAULT_AGENT_ID,
+  EFFORT_CONFIG_ID,
+  FAST_MODE_CONFIG_ID,
+  FAST_MODE_OFF,
+  FAST_MODE_ON,
+  MODEL_CONFIG_ID,
+  MODE_CONFIG_ID,
+  buildAvailableModes,
+  buildConfigOptions,
+  clientSupportsBooleanConfigOptions,
+  createFastModeConfigOption,
+  fastModeStateEnabled,
+  getClaudeBaselineConfig,
+  resolveFastModeEnabled
+};