swixter 0.1.10 → 0.1.12

package/dist/cli/index.js

@@ -14021,7 +14021,7 @@ var CONFIG_VERSION = "2.0.0", EXPORT_VERSION = "1.0.0";
 var init_versions2 = () => {};
 
 // src/constants/meta.ts
-var APP_VERSION = "0.1.10";
+var APP_VERSION = "0.1.12";
 var init_meta = () => {};
 
 // src/constants/install.ts
@@ -14459,6 +14459,7 @@ var init_presets = __esm(() => {
     name: "MiniMax CN",
     displayName: "MiniMax (CN)",
     baseURL: "https://api.minimaxi.com/anthropic",
+    baseURLChat: "https://api.minimaxi.com/v1",
     defaultModels: [
       "MiniMax-M2.7"
     ],
@@ -14474,6 +14475,7 @@ var init_presets = __esm(() => {
     name: "MiniMax Global",
     displayName: "MiniMax (Global)",
     baseURL: "https://api.minimax.io/anthropic",
+    baseURLChat: "https://api.minimax.io/v1",
     defaultModels: [
       "MiniMax-M2.7"
     ],
@@ -18986,10 +18988,12 @@ import { join as join3, dirname as dirname4 } from "node:path";
 class CodexAdapter {
   name = "codex";
   configPath;
-  authPath;
   constructor() {
-    this.configPath = join3(homedir2(), ".codex", "config.toml");
-    this.authPath = join3(homedir2(), ".codex", "auth.json");
+    const codexHome = join3(homedir2(), ".codex");
+    this.configPath = join3(codexHome, "config.toml");
+  }
+  getProfileFilePath(profileName) {
+    return join3(dirname4(this.configPath), `swixter-${profileName}.config.toml`);
   }
   async apply(profile) {
     try {
@@ -19019,15 +19023,17 @@ class CodexAdapter {
         config2.model_providers = {};
       }
       config2.model_providers[providerName] = await this.createProviderTable(profile, preset);
-      if (!config2.profiles) {
-        config2.profiles = {};
-      }
-      config2.profiles[profileName] = await this.createProfileTable(profile, providerName);
-      config2.profile = profileName;
       config2.model_provider = providerName;
+      delete config2.profile;
+      if (config2.profiles) {
+        delete config2.profiles[profileName];
+        if (Object.keys(config2.profiles).length === 0) {
+          delete config2.profiles;
+        }
+      }
       const tomlContent = stringify(config2);
       await writeFile4(this.configPath, tomlContent, "utf-8");
-      await this.writeAuthJson(profile);
+      await this.writeProfileFile(profile, providerName);
     } catch (error46) {
       throw new Error(`Failed to apply Codex configuration: ${error46 instanceof Error ? error46.message : String(error46)}`);
     }
@@ -19039,32 +19045,24 @@ class CodexAdapter {
       }
       const content = await readFile4(this.configPath, "utf-8");
       const config2 = parse5(content);
-      const profileName = `swixter-${profile.name}`;
-      if (config2.profile !== profileName) {
+      const providerName = `swixter-${profile.name}`;
+      if (config2.model_provider !== providerName) {
         return false;
       }
-      if (!config2.profiles || !config2.profiles[profileName]) {
+      if (!config2.model_providers || !config2.model_providers[providerName]) {
         return false;
       }
-      const providerName = config2.profiles[profileName].model_provider;
-      if (!config2.model_providers || !config2.model_providers[providerName]) {
+      const profileFilePath = this.getProfileFilePath(profile.name);
+      if (!existsSync4(profileFilePath)) {
         return false;
       }
-      if (profile.apiKey) {
-        const envKey = await getEnvKey(profile);
-        if (existsSync4(this.authPath)) {
-          try {
-            const authContent = await readFile4(this.authPath, "utf-8");
-            const auth = JSON.parse(authContent);
-            if (auth[envKey] !== profile.apiKey) {
-              return false;
-            }
-          } catch {
-            return false;
-          }
-        } else {
+      try {
+        const profileFile = parse5(await readFile4(profileFilePath, "utf-8"));
+        if (profileFile.model_provider !== providerName) {
           return false;
         }
+      } catch {
+        return false;
       }
       return true;
     } catch (error46) {
@@ -19076,8 +19074,7 @@ class CodexAdapter {
     const providerTable = {
       name: preset.displayName,
       base_url: profile.baseURL || baseUrl,
-      wire_api: "responses",
-      requires_openai_auth: true
+      wire_api: "responses"
     };
     providerTable.env_key = await getEnvKey(profile);
     if (preset.headers) {
@@ -19085,45 +19082,21 @@ class CodexAdapter {
     }
     return providerTable;
   }
-  async createProfileTable(profile, providerName) {
-    const profileTable = {
+  async writeProfileFile(profile, providerName) {
+    const profileContent = {
       model_provider: providerName
     };
     const modelValue = getOpenAIModel(profile);
     if (modelValue) {
-      profileTable.model = modelValue;
+      profileContent.model = modelValue;
     } else {
       const preset = await getPresetByIdAsync(profile.providerId);
       if (preset && preset.defaultModels && preset.defaultModels.length > 0) {
-        profileTable.model = preset.defaultModels[0];
+        profileContent.model = preset.defaultModels[0];
       }
     }
-    return profileTable;
-  }
-  async writeAuthJson(profile) {
-    const envKey = await getEnvKey(profile);
-    let auth = {};
-    if (existsSync4(this.authPath)) {
-      try {
-        const content = await readFile4(this.authPath, "utf-8");
-        const parsed = JSON.parse(content);
-        if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-          auth = parsed;
-        }
-      } catch {
-        auth = {};
-      }
-    }
-    if (profile.apiKey) {
-      auth[envKey] = profile.apiKey;
-    } else {
-      delete auth[envKey];
-    }
-    if (Object.keys(auth).length > 0) {
-      await writeFile4(this.authPath, JSON.stringify(auth, null, 2), "utf-8");
-    } else if (existsSync4(this.authPath)) {
-      await unlink(this.authPath);
-    }
+    const profileFilePath = this.getProfileFilePath(profile.name);
+    await writeFile4(profileFilePath, stringify(profileContent), "utf-8");
   }
   async getEnvExportCommands(profile) {
     const commands = await getEnvExportCommands(profile);
@@ -19134,6 +19107,12 @@ class CodexAdapter {
     return commands;
   }
   async remove(profileName) {
+    const profileFilePath = this.getProfileFilePath(profileName);
+    if (existsSync4(profileFilePath)) {
+      try {
+        await unlink(profileFilePath);
+      } catch {}
+    }
     if (!existsSync4(this.configPath)) {
       return;
     }
@@ -19141,20 +19120,23 @@ class CodexAdapter {
       const content = await readFile4(this.configPath, "utf-8");
       const config2 = parse5(content);
       const providerKey = `swixter-${profileName}`;
-      const profileKey = `swixter-${profileName}`;
       let modified = false;
-      let envKeyToRemove;
       if (config2.model_providers && config2.model_providers[providerKey]) {
-        envKeyToRemove = config2.model_providers[providerKey].env_key;
         delete config2.model_providers[providerKey];
         modified = true;
       }
-      if (config2.profiles && config2.profiles[profileKey]) {
-        delete config2.profiles[profileKey];
+      if (config2.profiles && config2.profiles[providerKey]) {
+        delete config2.profiles[providerKey];
+        if (Object.keys(config2.profiles).length === 0) {
+          delete config2.profiles;
+        }
         modified = true;
       }
-      if (config2.profile === profileKey) {
+      if (config2.profile === providerKey) {
         delete config2.profile;
+        modified = true;
+      }
+      if (config2.model_provider === providerKey) {
         delete config2.model_provider;
         modified = true;
       }
@@ -19162,14 +19144,6 @@ class CodexAdapter {
         const tomlContent = stringify(config2);
         await writeFile4(this.configPath, tomlContent, "utf-8");
       }
-      if (envKeyToRemove && existsSync4(this.authPath)) {
-        try {
-          const authContent = await readFile4(this.authPath, "utf-8");
-          const auth = JSON.parse(authContent);
-          delete auth[envKeyToRemove];
-          await writeFile4(this.authPath, JSON.stringify(auth, null, 2), "utf-8");
-        } catch {}
-      }
     } catch (error46) {
       console.warn(`Failed to remove profile from Codex config: ${error46}`);
     }
@@ -19180,6 +19154,7 @@ var init_codex = __esm(() => {
   init_presets();
   init_model_helper();
   init_env_key_helper();
+  init_env_key_helper();
 });
 
 // src/adapters/index.ts
@@ -25718,19 +25693,23 @@ function parseSSEEvents(chunk) {
     if (currentDataLines.length > 0) {
       const dataStr = currentDataLines.join(`
 `);
-      try {
-        const data = JSON.parse(dataStr);
-        events.push({ event: currentEvent, data });
-      } catch {}
+      if (dataStr === "[DONE]") {
+        events.push({ event: currentEvent, data: "[DONE]" });
+      } else {
+        try {
+          const data = JSON.parse(dataStr);
+          events.push({ event: currentEvent, data });
+        } catch {}
+      }
     }
     currentEvent = "";
     currentDataLines = [];
   }
   for (const line of lines) {
-    if (line.startsWith("event: ")) {
-      currentEvent = line.slice("event: ".length);
-    } else if (line.startsWith("data: ")) {
-      currentDataLines.push(line.slice("data: ".length));
+    if (line.startsWith("event:")) {
+      currentEvent = line.slice("event:".length).replace(/^ /, "");
+    } else if (line.startsWith("data:")) {
+      currentDataLines.push(line.slice("data:".length).replace(/^ /, ""));
     } else if (line === "") {
       flushEvent();
     }
@@ -25889,7 +25868,7 @@ function inferClientFormat(endpoint) {
     return "openai_chat";
   }
   if (endpoint.includes("/v1/responses")) {
-    return "anthropic_responses";
+    return "openai_responses";
   }
   if (endpoint.includes("/anthropic/") || endpoint.includes("/v1/messages")) {
     return "anthropic_messages";
@@ -26412,6 +26391,446 @@ var init_openai_chat_to_anthropic2 = __esm(() => {
   });
 });
 
+// src/proxy/transform/request/openai-responses-to-openai-chat.ts
+function openaiResponsesToOpenAIChatRequest(body, _ctx) {
+  const r2 = body;
+  const chatBody = { model: r2.model };
+  const messages2 = [];
+  if (typeof r2.instructions === "string" && r2.instructions.length > 0) {
+    messages2.push({ role: "system", content: r2.instructions });
+  }
+  if (Array.isArray(r2.input)) {
+    for (const item of r2.input) {
+      const converted = convertInputItem(item);
+      if (Array.isArray(converted))
+        messages2.push(...converted);
+      else if (converted)
+        messages2.push(converted);
+    }
+  } else if (typeof r2.input === "string" && r2.input.length > 0) {
+    messages2.push({ role: "user", content: r2.input });
+  }
+  chatBody.messages = messages2;
+  if (r2.max_output_tokens !== undefined)
+    chatBody.max_tokens = r2.max_output_tokens;
+  if (r2.temperature !== undefined)
+    chatBody.temperature = r2.temperature;
+  if (r2.top_p !== undefined)
+    chatBody.top_p = r2.top_p;
+  if (r2.stream !== undefined)
+    chatBody.stream = r2.stream;
+  if (r2.parallel_tool_calls !== undefined)
+    chatBody.parallel_tool_calls = r2.parallel_tool_calls;
+  if (Array.isArray(r2.tools)) {
+    chatBody.tools = r2.tools.filter((t) => {
+      const name = t.name;
+      if (typeof name !== "string" || name.length === 0)
+        return false;
+      return TOOL_NAME_RE.test(name);
+    }).map((t) => ({
+      type: "function",
+      function: {
+        name: t.name,
+        description: t.description,
+        parameters: t.parameters && typeof t.parameters === "object" ? t.parameters : { type: "object", properties: {} }
+      }
+    }));
+  }
+  if (r2.tool_choice !== undefined)
+    chatBody.tool_choice = convertToolChoice2(r2.tool_choice);
+  const effort = r2.reasoning?.effort;
+  if (typeof effort === "string")
+    chatBody.reasoning_effort = effort;
+  return { body: chatBody, targetEndpoint: "/v1/chat/completions" };
+}
+function convertInputItem(item) {
+  switch (item.type) {
+    case "message": {
+      const role = item.role === "developer" ? "system" : item.role;
+      return { role, content: flattenText(item.content) };
+    }
+    case "function_call": {
+      return {
+        role: "assistant",
+        content: null,
+        tool_calls: [{ id: item.call_id, type: "function", function: { name: item.name, arguments: item.arguments ?? "" } }]
+      };
+    }
+    case "function_call_output": {
+      return {
+        role: "tool",
+        tool_call_id: item.call_id,
+        content: typeof item.output === "string" ? item.output : JSON.stringify(item.output ?? "")
+      };
+    }
+    default:
+      return null;
+  }
+}
+function flattenText(content) {
+  if (typeof content === "string")
+    return content;
+  if (!Array.isArray(content))
+    return content;
+  const parts = [];
+  for (const part of content) {
+    if (part.type === "input_text" || part.type === "output_text" || part.type === "text") {
+      parts.push({ type: "text", text: part.text });
+    } else {
+      throw new Error(`openai_responses→openai_chat: unsupported content part type "${part.type}"`);
+    }
+  }
+  if (parts.length === 1 && parts[0].type === "text") {
+    return parts[0].text;
+  }
+  return parts;
+}
+function convertToolChoice2(tc) {
+  if (typeof tc === "string")
+    return tc;
+  if (tc && typeof tc === "object") {
+    const t = tc;
+    if (t.type === "function" && t.name) {
+      return { type: "function", function: { name: t.name } };
+    }
+  }
+  return tc;
+}
+var TOOL_NAME_RE;
+var init_openai_responses_to_openai_chat = __esm(() => {
+  TOOL_NAME_RE = /^(?!.*__)[a-zA-Z][a-zA-Z0-9_-]{0,63}$/;
+});
+
+// src/proxy/transform/response/openai-chat-to-openai-responses.ts
+function openAIChatToOpenAIResponsesResponse(body, _ctx) {
+  const chat = body;
+  const choices = chat.choices;
+  const choice = choices?.[0];
+  const message = choice?.message;
+  const output = [];
+  if (message) {
+    if (typeof message.content === "string" && message.content.length > 0) {
+      output.push({
+        type: "message",
+        id: "msg_0",
+        status: "completed",
+        role: "assistant",
+        content: [{ type: "output_text", text: message.content, annotations: [] }]
+      });
+    }
+    if (Array.isArray(message.tool_calls)) {
+      message.tool_calls.forEach((tc, i2) => {
+        const fn = tc.function || {};
+        output.push({
+          type: "function_call",
+          id: `fc_${i2}`,
+          call_id: tc.id,
+          name: fn.name,
+          arguments: typeof fn.arguments === "string" ? fn.arguments : JSON.stringify(fn.arguments ?? ""),
+          status: "completed"
+        });
+      });
+    }
+  }
+  const usage = chat.usage;
+  const inputTokens = usage?.prompt_tokens ?? 0;
+  const outputTokens = usage?.completion_tokens ?? 0;
+  const base = chat.id ? `resp_${chat.id}` : "";
+  const id = base && base !== "resp_" ? base : `resp_${Date.now()}`;
+  return {
+    id,
+    object: "response",
+    status: mapStatus(choice?.finish_reason),
+    model: chat.model ?? "unknown",
+    output,
+    usage: {
+      input_tokens: inputTokens,
+      output_tokens: outputTokens,
+      total_tokens: usage?.total_tokens ?? inputTokens + outputTokens
+    }
+  };
+}
+function mapStatus(finishReason) {
+  if (finishReason === "length")
+    return "incomplete";
+  return "completed";
+}
+
+// src/proxy/transform/streaming/openai-chat-to-openai-responses.ts
+function createOpenAIChatToOpenAIResponsesStream(source, ctx) {
+  const stream = source instanceof Uint8Array ? new ReadableStream({
+    start(controller) {
+      controller.enqueue(source);
+      controller.close();
+    }
+  }) : source;
+  return stream.pipeThrough(createSSETransformStream(new OpenAIChatToOpenAIResponsesStreamTransformer(ctx)));
+}
+var OpenAIChatToOpenAIResponsesStreamTransformer;
+var init_openai_chat_to_openai_responses = __esm(() => {
+  init_base();
+  init_transform();
+  init_openai_responses_to_openai_chat();
+  OpenAIChatToOpenAIResponsesStreamTransformer = class OpenAIChatToOpenAIResponsesStreamTransformer extends SSEStreamTransformer {
+    responseId = "";
+    model = "";
+    created = false;
+    textOutputIndex = -1;
+    textStarted = false;
+    textBuf = "";
+    tools = new Map;
+    nextOutputIndex = 0;
+    usage = null;
+    finished = false;
+    convertEvent(event) {
+      if (event.data === "[DONE]")
+        return null;
+      const data = event.data;
+      if (data && data.id)
+        this.responseId = `resp_${data.id}`;
+      if (data && data.model)
+        this.model = data.model;
+      if (data && data.usage)
+        this.usage = data.usage;
+      const choices = data?.choices;
+      const choice = choices?.[0];
+      if (!choice)
+        return null;
+      const out = [];
+      if (!this.created) {
+        this.created = true;
+        out.push({
+          event: "response.created",
+          data: { type: "response.created", response: this.responseShell("in_progress") }
+        });
+      }
+      const delta = choice.delta;
+      if (delta?.content && typeof delta.content === "string") {
+        out.push(...this.handleText(delta.content));
+      }
+      if (Array.isArray(delta?.tool_calls)) {
+        for (const tc of delta.tool_calls)
+          out.push(...this.handleTool(tc));
+      }
+      if (choice.finish_reason && !this.finished) {
+        out.push(...this.finish(choice.finish_reason));
+      }
+      return out;
+    }
+    responseShell(status) {
+      return { id: this.responseId, object: "response", status, model: this.model, output: [] };
+    }
+    handleText(text) {
+      this.textBuf += text;
+      const out = [];
+      if (this.textOutputIndex < 0)
+        this.textOutputIndex = this.nextOutputIndex++;
+      if (!this.textStarted) {
+        this.textStarted = true;
+        out.push({
+          event: "response.output_item.added",
+          data: {
+            type: "response.output_item.added",
+            output_index: this.textOutputIndex,
+            item: { type: "message", id: "msg_0", status: "in_progress", role: "assistant", content: [] }
+          }
+        });
+        out.push({
+          event: "response.content_part.added",
+          data: {
+            type: "response.content_part.added",
+            item_id: "msg_0",
+            output_index: this.textOutputIndex,
+            content_index: 0,
+            part: { type: "output_text", text: "", annotations: [] }
+          }
+        });
+      }
+      out.push({
+        event: "response.output_text.delta",
+        data: {
+          type: "response.output_text.delta",
+          item_id: "msg_0",
+          output_index: this.textOutputIndex,
+          content_index: 0,
+          delta: text
+        }
+      });
+      return out;
+    }
+    handleTool(tc) {
+      const idx = tc.index ?? 0;
+      let st = this.tools.get(idx);
+      if (!st) {
+        st = {
+          outputIndex: this.nextOutputIndex++,
+          itemId: `fc_${idx}`,
+          callId: tc.id ?? `call_${idx}`,
+          name: "",
+          argsBuf: "",
+          announced: false
+        };
+        this.tools.set(idx, st);
+      }
+      if (tc.id)
+        st.callId = tc.id;
+      if (tc.function?.name)
+        st.name = tc.function.name;
+      const out = [];
+      if (!st.announced && st.name) {
+        st.announced = true;
+        out.push({
+          event: "response.output_item.added",
+          data: {
+            type: "response.output_item.added",
+            output_index: st.outputIndex,
+            item: {
+              type: "function_call",
+              id: st.itemId,
+              call_id: st.callId,
+              name: st.name,
+              arguments: "",
+              status: "in_progress"
+            }
+          }
+        });
+      }
+      if (tc.function?.arguments) {
+        st.argsBuf += tc.function.arguments;
+        if (st.announced) {
+          out.push({
+            event: "response.function_call_arguments.delta",
+            data: {
+              type: "response.function_call_arguments.delta",
+              item_id: st.itemId,
+              output_index: st.outputIndex,
+              delta: tc.function.arguments
+            }
+          });
+        }
+      }
+      return out;
+    }
+    finish(_finishReason) {
+      if (this.finished)
+        return [];
+      this.finished = true;
+      const out = [];
+      if (this.textStarted) {
+        out.push({
+          event: "response.output_text.done",
+          data: {
+            type: "response.output_text.done",
+            item_id: "msg_0",
+            output_index: this.textOutputIndex,
+            content_index: 0,
+            text: this.textBuf
+          }
+        });
+        out.push({
+          event: "response.content_part.done",
+          data: {
+            type: "response.content_part.done",
+            item_id: "msg_0",
+            output_index: this.textOutputIndex,
+            content_index: 0,
+            part: { type: "output_text", text: this.textBuf, annotations: [] }
+          }
+        });
+        out.push({
+          event: "response.output_item.done",
+          data: {
+            type: "response.output_item.done",
+            output_index: this.textOutputIndex,
+            item: {
+              type: "message",
+              id: "msg_0",
+              status: "completed",
+              role: "assistant",
+              content: [{ type: "output_text", text: this.textBuf, annotations: [] }]
+            }
+          }
+        });
+      }
+      const outputItems = [];
+      if (this.textStarted) {
+        outputItems.push({
+          type: "message",
+          id: "msg_0",
+          status: "completed",
+          role: "assistant",
+          content: [{ type: "output_text", text: this.textBuf, annotations: [] }]
+        });
+      }
+      for (const st of this.tools.values()) {
+        if (!st.announced)
+          continue;
+        out.push({
+          event: "response.function_call_arguments.done",
+          data: {
+            type: "response.function_call_arguments.done",
+            item_id: st.itemId,
+            output_index: st.outputIndex,
+            arguments: st.argsBuf
+          }
+        });
+        out.push({
+          event: "response.output_item.done",
+          data: {
+            type: "response.output_item.done",
+            output_index: st.outputIndex,
+            item: {
+              type: "function_call",
+              id: st.itemId,
+              call_id: st.callId,
+              name: st.name,
+              arguments: st.argsBuf,
+              status: "completed"
+            }
+          }
+        });
+        outputItems.push({
+          type: "function_call",
+          id: st.itemId,
+          call_id: st.callId,
+          name: st.name,
+          arguments: st.argsBuf,
+          status: "completed"
+        });
+      }
+      const u2 = this.usage ?? {};
+      const inputTokens = u2.prompt_tokens ?? 0;
+      const outputTokens = u2.completion_tokens ?? 0;
+      out.push({
+        event: "response.completed",
+        data: {
+          type: "response.completed",
+          response: {
+            id: this.responseId,
+            object: "response",
+            status: "completed",
+            model: this.model,
+            output: outputItems,
+            usage: {
+              input_tokens: inputTokens,
+              output_tokens: outputTokens,
+              total_tokens: u2.total_tokens ?? inputTokens + outputTokens
+            }
+          }
+        }
+      });
+      return out;
+    }
+  };
+  registerTransformer({
+    clientFormat: "openai_responses",
+    targetFormat: "openai_chat",
+    requestTransform: openaiResponsesToOpenAIChatRequest,
+    responseTransform: openAIChatToOpenAIResponsesResponse,
+    streamTransform: (stream, ctx) => createOpenAIChatToOpenAIResponsesStream(stream, ctx)
+  });
+});
+
 // src/proxy/router.ts
 class ProxyRouter {
   routes = [];
@@ -26497,8 +26916,9 @@ class ProxyForwarder {
   defaultTimeout = 3000000;
   async forward(request, profile, timeoutMs) {
     const preset = await getPresetByIdAsync(profile.providerId);
-    const baseURL = profile.baseURL || preset?.baseURL || "";
-    const url2 = `${baseURL}${request.path}`;
+    const baseURL = (profile.baseURL || preset?.baseURL || "").replace(/\/+$/, "");
+    const path = baseURL.endsWith("/v1") && request.path.startsWith("/v1/") ? request.path.slice(3) : request.path;
+    const url2 = `${baseURL}${path}`;
     const timeout = timeoutMs || this.defaultTimeout;
     const headers = Object.fromEntries(Object.entries(request.headers).filter(([key]) => {
       const normalizedKey = key.toLowerCase();
@@ -27124,6 +27544,7 @@ class ProxyHandler {
 }
 var init_handler = __esm(() => {
   init_openai_chat_to_anthropic2();
+  init_openai_chat_to_openai_responses();
   init_model_helper();
   init_forwarder();
   init_manager2();
@@ -30341,9 +30762,10 @@ async function cmdApply3() {
       console.log(`  Provider: ${import_picocolors10.default.yellow(preset?.displayName)}`);
       console.log(`  Config file: ${import_picocolors10.default.dim(adapter.configPath)}`);
       console.log();
-      console.log(import_picocolors10.default.bold("Run Codex now: ") + import_picocolors10.default.cyan("codex"));
+      console.log(import_picocolors10.default.bold("Run Codex now: ") + import_picocolors10.default.cyan("swixter codex run"));
       console.log();
-      console.log(import_picocolors10.default.dim("Environment variables are automatically managed via auth.json."));
+      const envKey = profile.envKey || preset?.env_key || "OPENAI_API_KEY";
+      console.log(import_picocolors10.default.dim(`Or export your key first:  export ${envKey}=<your-key>  then run  codex`));
       console.log();
     } else {
       console.log(import_picocolors10.default.yellow("⚠  Profile written, but verification failed"));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "swixter",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "description": "CLI tool for managing AI coding assistant configurations - easily switch between providers (Claude Code, Codex, Continue) with Anthropic, Ollama, or custom APIs",
   "main": "dist/cli/index.js",
   "module": "dist/cli/index.js",