@telepat/ideon 0.1.5 → 0.1.6

package/dist/ideon.js

@@ -56,6 +56,7 @@ var appSettingsSchema = z.object({
 var envSettingsSchema = z.object({
   openRouterApiKey: z.string().optional(),
   replicateApiToken: z.string().optional(),
+  disableKeytar: z.boolean().optional(),
   model: z.string().optional(),
   temperature: z.number().min(0).max(2).optional(),
   maxTokens: z.number().int().positive().optional(),
@@ -100,6 +101,7 @@ function readEnvSettings(env = process.env) {
   return envSettingsSchema.parse({
     openRouterApiKey: env.IDEON_OPENROUTER_API_KEY,
     replicateApiToken: env.IDEON_REPLICATE_API_TOKEN,
+    disableKeytar: parseBoolean(env.IDEON_DISABLE_KEYTAR),
     model: env.IDEON_MODEL,
     temperature: parseNumber(env.IDEON_TEMPERATURE),
     maxTokens: parseNumber(env.IDEON_MAX_TOKENS),
@@ -1200,17 +1202,80 @@ import keytar from "keytar";
 var SERVICE_NAME = "ideon";
 var OPENROUTER_ACCOUNT = "openrouter-api-key";
 var REPLICATE_ACCOUNT = "replicate-api-token";
-async function loadSecrets() {
-  const [openRouterApiKey, replicateApiToken] = await Promise.all([
-    keytar.getPassword(SERVICE_NAME, OPENROUTER_ACCOUNT),
-    keytar.getPassword(SERVICE_NAME, REPLICATE_ACCOUNT)
-  ]);
+var KEYTAR_UNAVAILABLE_ERROR_NAME = "KeytarUnavailableError";
+var hasWarnedAboutUnavailableKeytar = false;
+var KeytarUnavailableError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = KEYTAR_UNAVAILABLE_ERROR_NAME;
+  }
+};
+function nullSecrets() {
   return {
-    openRouterApiKey,
-    replicateApiToken
+    openRouterApiKey: null,
+    replicateApiToken: null
   };
 }
-async function saveSecrets(secrets) {
+function shouldDisableKeytar(options) {
+  return options.disableKeytar === true;
+}
+function isKeytarAvailabilityError(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  const lowered = error.message.toLowerCase();
+  return [
+    "dbus",
+    "d-bus",
+    "org.freedesktop.secrets",
+    "secret service",
+    "secret-service",
+    "keychain",
+    "keyring",
+    "credential store",
+    "credentials were unavailable",
+    "cannot autolaunch",
+    "no such interface",
+    "not supported in this environment"
+  ].some((fragment) => lowered.includes(fragment));
+}
+function warnKeytarUnavailable(details) {
+  if (hasWarnedAboutUnavailableKeytar) {
+    return;
+  }
+  hasWarnedAboutUnavailableKeytar = true;
+  console.warn(
+    `System keychain unavailable (${details}). Falling back to environment variables for secrets. Set IDEON_DISABLE_KEYTAR=true to skip keychain access in this environment.`
+  );
+}
+async function loadSecrets(options = {}) {
+  if (shouldDisableKeytar(options)) {
+    return nullSecrets();
+  }
+  try {
+    const [openRouterApiKey, replicateApiToken] = await Promise.all([
+      keytar.getPassword(SERVICE_NAME, OPENROUTER_ACCOUNT),
+      keytar.getPassword(SERVICE_NAME, REPLICATE_ACCOUNT)
+    ]);
+    return {
+      openRouterApiKey,
+      replicateApiToken
+    };
+  } catch (error) {
+    if (isKeytarAvailabilityError(error)) {
+      const message = error instanceof Error ? error.message : "unknown error";
+      warnKeytarUnavailable(message);
+      return nullSecrets();
+    }
+    throw error;
+  }
+}
+async function saveSecrets(secrets, options = {}) {
+  if (shouldDisableKeytar(options)) {
+    throw new KeytarUnavailableError(
+      "System keychain access is disabled by IDEON_DISABLE_KEYTAR=true. Use IDEON_OPENROUTER_API_KEY and IDEON_REPLICATE_API_TOKEN instead."
+    );
+  }
   const tasks = [];
   if (secrets.openRouterApiKey !== void 0) {
     tasks.push(saveSecretValue(OPENROUTER_ACCOUNT, secrets.openRouterApiKey));
@@ -1221,17 +1286,31 @@ async function saveSecrets(secrets) {
   await Promise.all(tasks);
 }
 async function saveSecretValue(account, value2) {
-  if (!value2) {
-    await keytar.deletePassword(SERVICE_NAME, account);
-    return;
+  try {
+    if (!value2) {
+      await keytar.deletePassword(SERVICE_NAME, account);
+      return;
+    }
+    await keytar.setPassword(SERVICE_NAME, account, value2);
+  } catch (error) {
+    if (isKeytarAvailabilityError(error)) {
+      const message = error instanceof Error ? error.message : "unknown error";
+      throw new KeytarUnavailableError(
+        `System keychain unavailable while saving credentials (${message}). Use IDEON_OPENROUTER_API_KEY and IDEON_REPLICATE_API_TOKEN instead.`
+      );
+    }
+    throw error;
   }
-  await keytar.setPassword(SERVICE_NAME, account, value2);
 }
 
 // src/cli/commands/settings.tsx
 import { jsx as jsx2 } from "react/jsx-runtime";
 async function openSettings() {
-  const [settings, secrets] = await Promise.all([loadSavedSettings(), loadSecrets()]);
+  const envSettings = readEnvSettings();
+  const [settings, secrets] = await Promise.all([
+    loadSavedSettings(),
+    loadSecrets({ disableKeytar: envSettings.disableKeytar })
+  ]);
   let result = null;
   const app = render(
     /* @__PURE__ */ jsx2(
@@ -1252,7 +1331,17 @@ async function openSettings() {
     return;
   }
   const savedResult = finalResult;
-  await Promise.all([saveSettings(savedResult.settings), saveSecrets(savedResult.secrets)]);
+  await saveSettings(savedResult.settings);
+  try {
+    await saveSecrets(savedResult.secrets, { disableKeytar: envSettings.disableKeytar });
+  } catch (error) {
+    if (error instanceof KeytarUnavailableError) {
+      console.log("Settings saved, but secrets were not stored in the system keychain.");
+      console.log("Use IDEON_OPENROUTER_API_KEY and IDEON_REPLICATE_API_TOKEN in this environment.");
+      return;
+    }
+    throw error;
+  }
   console.log(`Settings saved to ${getSettingsFilePath()}.`);
 }
 
@@ -3526,8 +3615,11 @@ import { createInterface } from "readline/promises";
 // src/config/resolver.ts
 import { readFile as readFile4 } from "fs/promises";
 async function resolveRunInput(input) {
-  const [savedSettings, secrets] = await Promise.all([loadSavedSettings(), loadSecrets()]);
   const envSettings = readEnvSettings();
+  const [savedSettings, secrets] = await Promise.all([
+    loadSavedSettings(),
+    loadSecrets({ disableKeytar: envSettings.disableKeytar })
+  ]);
   const job = input.jobPath ? await loadJobInput(input.jobPath) : null;
   assertNoLegacyXMode(savedSettings.contentTargets, "saved settings contentTargets");
   assertNoLegacyXMode(job?.settings?.contentTargets, "job settings contentTargets");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@telepat/ideon",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "CLI for generating rich articles and images from ideas.",
   "type": "module",
   "repository": {