sentinelayer-cli 0.44.0 → 0.45.0

package/src/commands/session.js

@@ -7,6 +7,7 @@ import { spawn as defaultSpawn } from "node:child_process";
 
 import pc from "picocolors";
 
+import { credentialFor, isAuthenticated } from "../auth/credential-destinations.js";
 import { SentinelayerApiError, requestJsonMutation } from "../auth/http.js";
 import {
   buildProvisionEmailPayload,
@@ -15,7 +16,6 @@ import {
   resolveAidenIdCredentials,
 } from "../ai/aidenid.js";
 import { recordProvisionedIdentity } from "../ai/identity-store.js";
-import { readStoredSession } from "../auth/session-store.js";
 import { fetchAidenIdCredentials } from "../auth/service.js";
 import { resolveActiveAuthSession } from "../auth/service.js";
 import { resolveOutputRoot } from "../config/service.js";
@@ -1322,19 +1322,11 @@ async function resolveSessionRemoteSyncState({ dashboardUrl } = {}) {
     };
   }
 
-  let storedSession = null;
-  try {
-    storedSession = await readStoredSession();
-  } catch {
-    storedSession = null;
-  }
-  const apiUrl =
-    normalizeString(storedSession?.apiUrl) ||
-    normalizeString(process.env.SENTINELAYER_API_URL) ||
-    "https://api.sentinelayer.com";
-  const hasToken = Boolean(
-    normalizeString(storedSession?.token) || normalizeString(process.env.SENTINELAYER_TOKEN),
+  const auth = await resolveActiveAuthSession({ cwd: process.cwd(), env: process.env, autoRotate: false }).catch(
+    () => null,
   );
+  const apiUrl = normalizeString(auth?.apiUrl) || "https://api.sentinelayer.com";
+  const hasToken = isAuthenticated(auth);
   if (!hasToken) {
     return {
       status: "auth_required",
@@ -1458,12 +1450,12 @@ async function findReusableSessionCandidate({
 //   - When `SENTINELAYER_SKIP_REMOTE_SYNC=1` (test bootstrap), short-circuits
 //     to `{ ok: true, source: "skipped", session: null }` so unit tests
 //     can exercise the local materialization path without a real API.
-async function fetchRemoteSessionDetail(endpoint, headers) {
+async function fetchRemoteSessionDetail(endpoint, credential) {
   let response;
   let payload;
   try {
     ({ response, payload } = await fetchJsonWithFullTimeout(
-      endpoint, { method: "GET", headers, redirect: "error" }, 2_000,
+      endpoint, { method: "GET", credential, redirect: "error" }, 2_000,
     ));
   } catch (err) {
     return {
@@ -1516,7 +1508,7 @@ async function verifyRemoteSession(sessionId, { targetPath } = {}) {
   } catch {
     return { ok: false, reason: "no_session" };
   }
-  if (!auth || !auth.token) {
+  if (!isAuthenticated(auth)) {
     return { ok: false, reason: "not_authenticated", status: 401 };
   }
   const apiUrl = String(auth.apiUrl || "").replace(/\/+$/, "");
@@ -1524,10 +1516,10 @@ async function verifyRemoteSession(sessionId, { targetPath } = {}) {
     return { ok: false, reason: "no_api_url" };
   }
   const endpoint = `${apiUrl}/api/v1/sessions/${encodeURIComponent(normalizedSessionId)}`;
-  const headers = { Authorization: `Bearer ${auth.token}` };
-  const firstAttempt = await fetchRemoteSessionDetail(endpoint, headers);
+  const credential = await credentialFor(auth);
+  const firstAttempt = await fetchRemoteSessionDetail(endpoint, credential);
   const detail = firstAttempt.retryable
-    ? await fetchRemoteSessionDetail(endpoint, headers)
+    ? await fetchRemoteSessionDetail(endpoint, credential)
     : firstAttempt;
   if (detail.ok) {
     return {
@@ -2782,7 +2774,7 @@ async function resolveAdminApiSession({ targetPath, explicitApiUrl }) {
     explicitApiUrl,
     autoRotate: true,
   });
-  if (!session || !session.token) {
+  if (!isAuthenticated(session)) {
     throw new Error(`No active auth token found. Run \`${authLoginHint()}\` first.`);
   }
   return session;
@@ -2802,10 +2794,8 @@ async function postAdminSessionMutation({
   return requestJsonMutation(`${apiUrl}${pathSuffix}`, {
     method: "POST",
     operationName,
-    headers: {
-      Authorization: `Bearer ${normalizeString(session.token)}`,
-      ...headers,
-    },
+    credential: await credentialFor(session),
+    headers,
     body,
   });
 }
@@ -3306,7 +3296,7 @@ export function registerSessionCommand(program) {
         env: process.env,
         autoRotate: false,
       });
-      if (!session?.token || !session?.apiUrl) {
+      if (!isAuthenticated(session) || !session?.apiUrl) {
         throw new Error(`Not authenticated. Run \`${authLoginHint()}\` first.`);
       }
       const apiUrl = String(session.apiUrl).replace(/\/+$/, "");
@@ -3315,7 +3305,7 @@ export function registerSessionCommand(program) {
         {
           method: "POST",
           operationName: "session.set_title",
-          headers: { Authorization: `Bearer ${session.token}` },
+          credential: session.credential,
           body: { title: normalizedTitle },
         },
       );
@@ -3356,7 +3346,7 @@ export function registerSessionCommand(program) {
         env: process.env,
         autoRotate: false,
       });
-      if (!session?.token || !session?.apiUrl) {
+      if (!isAuthenticated(session) || !session?.apiUrl) {
         throw new Error(`Not authenticated. Run \`${authLoginHint()}\` first.`);
       }
       const apiUrl = String(session.apiUrl).replace(/\/+$/, "");
@@ -3365,7 +3355,7 @@ export function registerSessionCommand(program) {
         {
           method: "POST",
           operationName: "session.sweep_empty",
-          headers: { Authorization: `Bearer ${session.token}` },
+          credential: session.credential,
           body: {
             cutoffMinutes,
             maxEvents,
@@ -6400,7 +6390,7 @@ export function registerSessionCommand(program) {
           env: process.env,
           autoRotate: false,
         });
-        if (!authSession || !authSession.token) {
+        if (!isAuthenticated(authSession)) {
           throw new Error(`Remote session read requires authentication. Run \`${authLoginHint()}\` first.`);
         }
         hydration = await hydrateSessionFromRemote({
@@ -6674,13 +6664,13 @@ export function registerSessionCommand(program) {
           autoRotate: false,
         }).catch(() => null);
         const apiBaseUrl = session?.apiUrl || "";
-        const token = session?.token || "";
+        const credential = session?.credential || null;
         try {
           for await (const item of mergeLiveSources({
             sessionId: normalizedSessionId,
             targetPath,
             apiBaseUrl: apiBaseUrl || undefined,
-            token: token || undefined,
+            credential: credential || undefined,
             signal: ac.signal,
           })) {
             if (item.event) {
@@ -8603,21 +8593,19 @@ export function registerSessionCommand(program) {
         return;
       }
 
-      let storedSession = null;
-      try {
-        storedSession = await readStoredSession();
-      } catch {
-        storedSession = null;
-      }
+      const storedSession = await resolveActiveAuthSession({
+        cwd: process.cwd(),
+        env: process.env,
+        autoRotate: false,
+      }).catch(() => null);
 
-      const fetchCredentials =
-        storedSession && storedSession.token
-          ? () =>
-              fetchAidenIdCredentials({
-                apiUrl: storedSession.apiUrl,
-                token: storedSession.token,
-              })
-          : null;
+      const fetchCredentials = isAuthenticated(storedSession)
+        ? () =>
+            fetchAidenIdCredentials({
+              apiUrl: storedSession.apiUrl,
+              auth: storedSession,
+            })
+        : null;
       const credentials = await resolveAidenIdCredentials({
         apiKey: options.apiKey,
         orgId: options.orgId,

package/src/commands/spec.js

@@ -10,7 +10,7 @@ import {
   resolveProvider,
 } from "../ai/client.js";
 import { recordCliLlmSessionUsage, usageNumber } from "../billing/llm-session-usage.js";
-import { loadConfig } from "../config/service.js";
+import { loadConfig, userConfigValues } from "../config/service.js";
 import { evaluateBudget } from "../cost/budget.js";
 import { appendCostEntry, summarizeCostHistory } from "../cost/history.js";
 import { estimateModelCost } from "../cost/tracker.js";
@@ -265,7 +265,7 @@ async function maybeEnhanceSpecWithAi({
     configModel: config.resolved.defaultModelId,
   });
   const explicitApiKey = String(options.apiKey || "").trim();
-  const configuredApiKey = resolveConfiguredApiKey(resolvedProvider, config.resolved);
+  const configuredApiKey = resolveConfiguredApiKey(resolvedProvider, userConfigValues(config));
 
   const prompt = buildAiSpecPrompt({
     baseSpecMarkdown,

package/src/commands/watch.js

@@ -13,6 +13,7 @@ import {
 } from "../auth/service.js";
 import { resolveOutputRoot } from "../config/service.js";
 import { authLoginHint } from "../ui/command-hints.js";
+import { isAuthenticated } from "../auth/credential-destinations.js";
 
 const TERMINAL_RUN_STATUSES = new Set(["completed", "failed", "cancelled"]);
 
@@ -369,7 +370,7 @@ export function registerWatchCommand(program) {
         throw new Error(formatApiError(error));
       }
 
-      if (!session || !session.token) {
+      if (!isAuthenticated(session)) {
         throw new Error(`No active auth token found. Run \`${authLoginHint()}\` first.`);
       }
 
@@ -395,7 +396,7 @@ export function registerWatchCommand(program) {
         while (true) {
           const response = await listRuntimeRunEvents({
             apiUrl: session.apiUrl,
-            authToken: session.token,
+            credential: session.credential,
             runId,
             afterEventId,
           });
@@ -428,7 +429,7 @@ export function registerWatchCommand(program) {
 
           const statusResponse = await getRuntimeRunStatus({
             apiUrl: session.apiUrl,
-            authToken: session.token,
+            credential: session.credential,
             runId,
           });
           latestStatus = String(statusResponse?.status || "unknown").trim().toLowerCase();

package/src/config/service.js

@@ -67,12 +67,49 @@ function normalizeLayerScope(scope, { allowResolved = true } = {}) {
   return normalized;
 }
 
+// Values a workspace .sentinelayer.yml may not set for the user: where the user's token goes, the
+// token itself, provider keys, and where alerts are sent. They come from the environment (where a
+// variable is named) or the global config only.
+const USER_ONLY_KEYS = Object.freeze({
+  apiUrl: "SENTINELAYER_API_URL",
+  sentinelayerToken: "SENTINELAYER_TOKEN",
+  openaiApiKey: "OPENAI_API_KEY",
+  anthropicApiKey: "ANTHROPIC_API_KEY",
+  googleApiKey: "GOOGLE_API_KEY",
+  "alerts.channels": "",
+});
+const noticedProjectFiles = new Set();
+
+function workspaceSets(projectConfig, key) {
+  const [head, field] = key.split(".");
+  const value = projectConfig?.[head];
+  return field ? value?.[field] !== undefined : value !== undefined;
+}
+
+// One notice per workspace config that sets any of them, so an ignored value is never silent.
+function noticeIgnoredWorkspaceValues(projectPath, projectConfig) {
+  const keys = Object.keys(USER_ONLY_KEYS).filter((key) => workspaceSets(projectConfig, key));
+  if (keys.length === 0 || noticedProjectFiles.has(projectPath)) return;
+  noticedProjectFiles.add(projectPath);
+  const envs = keys.map((key) => USER_ONLY_KEYS[key]).filter(Boolean);
+  const instead = envs.length > 0 ? `set ${envs.join(", ")} or the global config` : "set them in the global config";
+  process.stderr.write(
+    `NOTICE: workspace .sentinelayer.yml ${keys.join(", ")} ignored; ${instead} (~/.sentinelayer/config.yml).\n`,
+  );
+}
+
+/** The user's own config values (global, then environment), never the workspace's. */
+export function userConfigValues(config) {
+  return { ...(config?.layers?.global || {}), ...(config?.layers?.env || {}) };
+}
+
 export async function loadConfig({ cwd = process.cwd(), env = process.env, homeDir } = {}) {
   const paths = getConfigPaths({ cwd, homeDir });
   const [globalConfig, projectConfig] = await Promise.all([
     readConfigFile(paths.global),
     readConfigFile(paths.project),
   ]);
+  noticeIgnoredWorkspaceValues(paths.project, projectConfig);
 
   const envConfig = buildEnvLayer(env);
   const resolved = configSchema.parse(mergeLayers(globalConfig, projectConfig, envConfig));

package/src/daemon/pulse.js

@@ -226,7 +226,8 @@ export function buildHealthSummary(agentStates) {
 
 /**
  * Send an alert to configured Slack/Telegram webhooks.
- * Reads config from env or .sentinelayer.yml.
+ * Channels come from the caller or the environment (SENTINELAYER_SLACK_WEBHOOK_URL,
+ * SENTINELAYER_TELEGRAM_BOT_TOKEN, SENTINELAYER_TELEGRAM_CHAT_ID), never a workspace file.
  * Fails silently — alert delivery must never block agent work.
  *
  * @param {object} alert - { headline, body, severity } from buildAlertPayload

package/src/daemon/watchdog.js

@@ -1,8 +1,7 @@
 import fsp from "node:fs/promises";
 import path from "node:path";
 
-import { parse as parseYaml } from "yaml";
-
+import { loadConfig } from "../config/service.js";
 import { listAssignments, resolveAssignmentLedgerStorage } from "./assignment-ledger.js";
 import { listBudgetStates } from "./budget-governor.js";
 import { listErrorQueue, resolveErrorDaemonStorage } from "./error-worker.js";
@@ -95,12 +94,48 @@ function normalizeBoolean(value, fallbackValue = false) {
   return fallbackValue;
 }
 
-function resolveEnvTemplate(value, env) {
-  const normalized = normalizeString(value);
-  if (!normalized) {
-    return "";
+// An alert channel may name its own settings by environment variable, and nothing else: a template
+// never reaches the user's token or a provider key, and a channel whose template cannot be filled
+// is refused rather than sent with a blank.
+const ALERT_TEMPLATE_NAMES = new Set(["SLACK_WEBHOOK_URL", "TELEGRAM_BOT_TOKEN", "TELEGRAM_CHAT_ID"]);
+const ALERT_TEMPLATE_PREFIX = /^SENTINELAYER_ALERT_[A-Z0-9_]+$/;
+const SLACK_WEBHOOK_HOST = "hooks.slack.com";
+const TELEGRAM_API_HOST = "api.telegram.org";
+const TELEGRAM_BOT_TOKEN_RE = /^\d+:[A-Za-z0-9_-]+$/;
+const TELEGRAM_CHAT_ID_RE = /^(?:-?\d+|@[A-Za-z0-9_]+)$/;
+
+class AlertChannelRefused extends Error {}
+
+function isAlertTemplateName(name) {
+  return ALERT_TEMPLATE_NAMES.has(name) || ALERT_TEMPLATE_PREFIX.test(name);
+}
+
+function resolveAlertTemplate(value, env) {
+  return normalizeString(value).replace(/\$\{([^}]*)\}/g, (_, name) => {
+    if (!isAlertTemplateName(name)) {
+      throw new AlertChannelRefused(
+        `\${${name}} is not an alert setting; alert channels may use SLACK_WEBHOOK_URL, TELEGRAM_BOT_TOKEN, TELEGRAM_CHAT_ID or SENTINELAYER_ALERT_* only.`
+      );
+    }
+    const resolved = normalizeString(env?.[name]);
+    if (!resolved) {
+      throw new AlertChannelRefused(`\${${name}} is not set.`);
+    }
+    return resolved;
+  });
+}
+
+function slackWebhookUrl(value) {
+  let url = null;
+  try {
+    url = new URL(value);
+  } catch {
+    // refused below
   }
-  return normalized.replace(/\$\{([A-Z0-9_]+)\}/g, (_, key) => normalizeString(env[key]));
+  if (!url || url.protocol !== "https:" || url.hostname !== SLACK_WEBHOOK_HOST || url.port || url.username || url.password) {
+    throw new AlertChannelRefused(`Slack alerts are sent only to https://${SLACK_WEBHOOK_HOST}/.`);
+  }
+  return url.href;
 }
 
 function computeSecondsSince(previousIso, nowIso) {
@@ -282,72 +317,71 @@ function buildRunId(nowIso, count) {
   return `watchdog-${token}-${String(count).padStart(4, "0")}`;
 }
 
+// A refused channel stays in the list with its reason, so it is reported and never sent.
 function normalizeChannel(channel = {}, env = process.env) {
   const type = normalizeString(channel.type).toLowerCase();
-  if (type === "slack") {
-    const webhookUrl = resolveEnvTemplate(
-      channel.webhook_url || channel.webhookUrl || channel.url || "",
-      env
-    );
-    return webhookUrl
-      ? {
-          type: "slack",
-          webhookUrl,
-        }
-      : null;
-  }
-  if (type === "telegram") {
-    const botToken = resolveEnvTemplate(channel.bot_token || channel.botToken || "", env);
-    const chatId = resolveEnvTemplate(channel.chat_id || channel.chatId || "", env);
-    return botToken && chatId
-      ? {
-          type: "telegram",
-          botToken,
-          chatId,
-        }
-      : null;
-  }
-  return null;
-}
-
-async function loadWatchdogConfig({ targetPath = ".", env = process.env } = {}) {
-  const configPath = path.join(path.resolve(String(targetPath || ".")), ".sentinelayer.yml");
-  const fallback = {
-    channels: [],
-    frequency: "smart",
-    events: ["agent_stuck", "budget_warning", "alert_recovered"],
-  };
   try {
-    const parsed = parseYaml(await fsp.readFile(configPath, "utf-8")) || {};
-    const alerts = parsed && typeof parsed === "object" ? normalizeObject(parsed.alerts) : {};
-    const channels = Array.isArray(alerts.channels)
-      ? alerts.channels.map((channel) => normalizeChannel(channel, env)).filter(Boolean)
-      : [];
-    const events = Array.isArray(alerts.events)
-      ? alerts.events
-          .map((eventType) => normalizeString(eventType))
-          .filter((eventType) => WATCHDOG_EVENT_SET.has(eventType))
-      : fallback.events;
-    const frequency = normalizeString(alerts.frequency).toLowerCase() || fallback.frequency;
-    return {
-      configPath,
-      exists: true,
-      channels,
-      frequency,
-      events: events.length > 0 ? events : fallback.events,
-    };
+    if (type === "slack") {
+      const webhookUrl = resolveAlertTemplate(
+        channel.webhook_url || channel.webhookUrl || channel.url || "",
+        env
+      );
+      return webhookUrl ? { type: "slack", webhookUrl: slackWebhookUrl(webhookUrl) } : null;
+    }
+    if (type === "telegram") {
+      const botToken = resolveAlertTemplate(channel.bot_token || channel.botToken || "", env);
+      const chatId = resolveAlertTemplate(channel.chat_id || channel.chatId || "", env);
+      if (!botToken || !chatId) {
+        return null;
+      }
+      if (!TELEGRAM_BOT_TOKEN_RE.test(botToken) || !TELEGRAM_CHAT_ID_RE.test(chatId)) {
+        throw new AlertChannelRefused("The Telegram bot token or chat id is not in Telegram's format.");
+      }
+      return { type: "telegram", botToken, chatId };
+    }
   } catch (error) {
-    if (error && typeof error === "object" && error.code === "ENOENT") {
-      return {
-        configPath,
-        exists: false,
-        channels: [],
-        frequency: fallback.frequency,
-        events: fallback.events,
-      };
+    if (error instanceof AlertChannelRefused) {
+      return { type, error: error.message };
     }
     throw error;
   }
+  return null;
+}
+
+// What a channel is, without its secrets (webhook URLs and bot tokens are credentials).
+function describeChannel(channel) {
+  if (channel.error) {
+    return { type: channel.type, error: channel.error };
+  }
+  return {
+    type: channel.type,
+    destination: channel.type === "slack" ? SLACK_WEBHOOK_HOST : TELEGRAM_API_HOST,
+  };
+}
+
+// Where alerts are sent comes from the user's own config (~/.sentinelayer/config.yml) only; a
+// workspace .sentinelayer.yml may choose which events alert, not where they go.
+async function loadWatchdogConfig({ targetPath = ".", env = process.env, homeDir } = {}) {
+  const config = await loadConfig({ cwd: path.resolve(String(targetPath || ".")), env, homeDir });
+  const configPath = config.paths.global;
+  const fallbackEvents = ["agent_stuck", "budget_warning", "alert_recovered"];
+  const userAlerts = normalizeObject(config.layers.global?.alerts);
+  const alerts = normalizeObject(config.resolved.alerts);
+  const channels = Array.isArray(userAlerts.channels)
+    ? userAlerts.channels.map((channel) => normalizeChannel(channel, env)).filter(Boolean)
+    : [];
+  const events = Array.isArray(alerts.events)
+    ? alerts.events
+        .map((eventType) => normalizeString(eventType))
+        .filter((eventType) => WATCHDOG_EVENT_SET.has(eventType))
+    : fallbackEvents;
+  return {
+    configPath,
+    exists: await fsp.access(configPath).then(() => true, () => false),
+    channels,
+    frequency: normalizeString(alerts.frequency).toLowerCase() || "smart",
+    events: events.length > 0 ? events : fallbackEvents,
+  };
 }
 
 function buildDetection({
@@ -581,6 +615,7 @@ function formatAlertMessage(alert = {}) {
 async function sendSlackAlert(channel, message, fetchImpl) {
   const response = await fetchImpl(channel.webhookUrl, {
     method: "POST",
+    redirect: "error",
     headers: {
       "content-type": "application/json",
     },
@@ -594,9 +629,10 @@ async function sendSlackAlert(channel, message, fetchImpl) {
 }
 
 async function sendTelegramAlert(channel, message, fetchImpl) {
-  const endpoint = `https://api.telegram.org/bot${channel.botToken}/sendMessage`;
+  const endpoint = `https://${TELEGRAM_API_HOST}/bot${channel.botToken}/sendMessage`;
   const response = await fetchImpl(endpoint, {
     method: "POST",
+    redirect: "error",
     headers: {
       "content-type": "application/json",
     },
@@ -618,6 +654,17 @@ async function dispatchAlertToChannel({
   fetchImpl = globalThis.fetch,
 }) {
   const message = formatAlertMessage(alert);
+  if (channel.error) {
+    return {
+      channelType: channel.type,
+      alertId: alert.alertId,
+      eventType: alert.eventType,
+      sent: false,
+      dryRun: false,
+      message,
+      error: channel.error,
+    };
+  }
   if (!execute) {
     return {
       channelType: channel.type,
@@ -750,6 +797,7 @@ export async function runWatchdogTick({
   const config = await loadWatchdogConfig({
     targetPath,
     env,
+    homeDir,
   });
 
   const [assignments, queue, budgets, previousState] = await Promise.all([
@@ -916,6 +964,7 @@ export async function getWatchdogStatus({
   const config = await loadWatchdogConfig({
     targetPath,
     env,
+    homeDir,
   });
   const state = await readJsonFile(storage.watchdogStatePath, () =>
     createInitialState(normalizedNow)
@@ -959,7 +1008,7 @@ export async function getWatchdogStatus({
     ...storage,
     configPath: config.configPath,
     configExists: config.exists,
-    config,
+    config: { ...config, channels: config.channels.map(describeChannel) },
     statePath: storage.watchdogStatePath,
     eventsPath: storage.watchdogEventsPath,
     state,