agor-live 0.22.0 → 0.23.2

package/dist/daemon/widgets/env-vars/index.js

@@ -5,7 +5,12 @@ var __export = (target, all) => {
 };
 
 // src/widgets/env-vars/index.ts
-import { ENV_VAR_CONSTRAINTS, isEnvVarAllowed, validateEnvVar } from "@agor/core/config";
+import {
+  ENV_VAR_CONSTRAINTS,
+  isEnvVarAllowed,
+  validateEnvVar
+} from "@agor/core/config";
+import { SessionEnvSelectionRepository } from "@agor/core/db";
 import { BadRequest } from "@agor/core/feathers";
 
 // ../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/classic/external.js
@@ -14536,6 +14541,30 @@ function registerWidget(entry) {
 
 // src/widgets/env-vars/index.ts
 var ENV_VAR_NAME_REGEX = ENV_VAR_CONSTRAINTS.NAME_PATTERN;
+function orderedEnvVarNames(names) {
+  return [...names].sort();
+}
+var envVarFieldMetadataSchema = external_exports.object({
+  description: external_exports.string().max(200).optional(),
+  placeholder: external_exports.string().max(120).optional(),
+  format_hint: external_exports.string().max(80).optional(),
+  input_type: external_exports.enum(["password", "text", "textarea"]).default("password").optional()
+}).strict();
+function orderedRecord(record2) {
+  if (!record2) return void 0;
+  const out = {};
+  for (const key of orderedEnvVarNames(Object.keys(record2))) {
+    out[key] = record2[key];
+  }
+  return out;
+}
+function normalizeEnvVarsParams(params) {
+  return {
+    ...params,
+    names: orderedEnvVarNames(params.names),
+    variable_metadata: orderedRecord(params.variable_metadata)
+  };
+}
 var envVarsParamsSchema = external_exports.object({
   names: external_exports.array(external_exports.string().regex(ENV_VAR_NAME_REGEX)).min(1).max(10).refine((names) => new Set(names).size === names.length, {
     message: "Env var names must be unique"
@@ -14543,50 +14572,136 @@ var envVarsParamsSchema = external_exports.object({
   reason: external_exports.string().min(1).max(200).describe(
     "One sentence explaining why you need the value(s). Keep it tight \u2014 this renders in a small muted line under the input. NOT a place to restate what the widget does."
   ),
+  variable_metadata: external_exports.record(external_exports.string().regex(ENV_VAR_NAME_REGEX), envVarFieldMetadataSchema).optional().describe(
+    "Optional per-variable display metadata keyed by requested name. Allowed keys per variable: description, placeholder, format_hint, input_type (password|text|textarea). Do not include values, defaults, examples containing secrets, or anything secret-like."
+  ),
   auto_resume: external_exports.boolean().default(true).describe(
     "When true (default), a system-authored prompt is auto-queued back into the agent on submit/dismiss."
   )
+}).superRefine((params, ctx) => {
+  const requested = new Set(params.names);
+  for (const key of Object.keys(params.variable_metadata ?? {})) {
+    if (!requested.has(key)) {
+      ctx.addIssue({
+        code: external_exports.ZodIssueCode.custom,
+        path: ["variable_metadata", key],
+        message: `Metadata key ${key} must match a requested env var name`
+      });
+    }
+  }
 });
 var envVarsSubmitSchema = external_exports.object({
   values: external_exports.record(
     external_exports.string().regex(ENV_VAR_NAME_REGEX),
     external_exports.string().min(1).max(ENV_VAR_CONSTRAINTS.MAX_VALUE_LENGTH)
-  ).refine((v) => Object.keys(v).length >= 1 && Object.keys(v).length <= 10, {
-    message: "Must submit between 1 and 10 env vars"
-  }),
+  ).default({}),
+  use_existing: external_exports.array(external_exports.string().regex(ENV_VAR_NAME_REGEX)).max(10).default([]).describe("Requested names whose already-saved global values should be used."),
   scope: external_exports.enum(["global", "session"])
+}).superRefine((submit, ctx) => {
+  const valueNames = Object.keys(submit.values);
+  const existingNames = submit.use_existing;
+  const total = valueNames.length + existingNames.length;
+  if (total < 1 || total > 10) {
+    ctx.addIssue({
+      code: external_exports.ZodIssueCode.custom,
+      message: "Must submit between 1 and 10 env vars"
+    });
+  }
+  const duplicates = existingNames.filter((name) => valueNames.includes(name));
+  for (const name of duplicates) {
+    ctx.addIssue({
+      code: external_exports.ZodIssueCode.custom,
+      path: ["use_existing"],
+      message: `Cannot both submit and use existing value for ${name}`
+    });
+  }
+  if (new Set(existingNames).size !== existingNames.length) {
+    ctx.addIssue({
+      code: external_exports.ZodIssueCode.custom,
+      path: ["use_existing"],
+      message: "use_existing names must be unique"
+    });
+  }
 });
+function fieldBadRequest(message, fieldErrors) {
+  return new BadRequest(message, { field_errors: orderedRecord(fieldErrors) });
+}
+function validationMessage(errors) {
+  return errors.map((e) => e.message).join("; ");
+}
 async function applyEnvVarsSubmit(ctx, submit, params) {
   const requestedNames = new Set(params.names);
-  const submittedNames = Object.keys(submit.values);
-  if (submittedNames.length !== params.names.length || submittedNames.some((name) => !requestedNames.has(name))) {
-    throw new BadRequest(
-      "Submitted env var names must exactly match the widget request: expected " + params.names.join(", ")
+  const submittedNames = orderedEnvVarNames(Object.keys(submit.values));
+  const useExistingNames = orderedEnvVarNames(submit.use_existing ?? []);
+  const coveredNames = orderedEnvVarNames([...submittedNames, ...useExistingNames]);
+  if (coveredNames.length !== params.names.length || coveredNames.some((name) => !requestedNames.has(name))) {
+    const missing = params.names.filter((name) => !coveredNames.includes(name));
+    const extra = coveredNames.filter((name) => !requestedNames.has(name));
+    const fieldErrors = {};
+    for (const name of missing)
+      fieldErrors[name] = "Required value or saved global value selection missing";
+    for (const name of extra) fieldErrors[name] = "This env var was not requested";
+    throw fieldBadRequest(
+      "Submitted env var names must exactly match the widget request: expected " + params.names.join(", "),
+      fieldErrors
     );
   }
   for (const name of submittedNames) {
     if (!isEnvVarAllowed(name)) {
-      throw new Error(`Cannot set environment variable "${name}": blocked by allow-list`);
+      throw fieldBadRequest(`Cannot set environment variable "${name}": blocked by allow-list`, {
+        [name]: "Blocked by allow-list"
+      });
     }
     const errors = validateEnvVar(name, submit.values[name]);
     if (errors.length > 0) {
-      throw new Error(`Invalid env var ${name}: ${errors.map((e) => e.message).join("; ")}`);
+      const message = validationMessage(errors);
+      throw fieldBadRequest(`Invalid env var ${name}: ${message}`, { [name]: message });
     }
   }
   const usersService = ctx.app.service("users");
+  if (useExistingNames.length > 0) {
+    const creator = await usersService.get(ctx.sessionCreatorUserId, {
+      user: { user_id: ctx.submitterUserId, role: ctx.submitterRole },
+      authenticated: true
+    });
+    const fieldErrors = {};
+    for (const name of useExistingNames) {
+      const meta3 = creator.env_vars?.[name];
+      if (!meta3?.set) {
+        fieldErrors[name] = "No saved value is set for this env var";
+      } else if (meta3.scope !== "global") {
+        fieldErrors[name] = "Only global saved values can be used from this widget";
+      }
+    }
+    if (Object.keys(fieldErrors).length > 0) {
+      throw fieldBadRequest("One or more saved values cannot be used", fieldErrors);
+    }
+  }
+  const orderedValues = {};
   const env_var_scopes = {};
   for (const name of submittedNames) {
+    orderedValues[name] = submit.values[name];
     env_var_scopes[name] = submit.scope;
   }
-  await usersService.patch(
-    ctx.sessionCreatorUserId,
-    { env_vars: submit.values, env_var_scopes },
-    {
-      user: { user_id: ctx.submitterUserId, role: ctx.submitterRole },
-      authenticated: true,
-      trustedEnvVarWrite: true
+  if (submittedNames.length > 0) {
+    await usersService.patch(
+      ctx.sessionCreatorUserId,
+      { env_vars: orderedValues, env_var_scopes },
+      {
+        user: { user_id: ctx.submitterUserId, role: ctx.submitterRole },
+        authenticated: true,
+        trustedEnvVarWrite: true
+      }
+    );
+  }
+  if (submit.scope === "session" && submittedNames.length > 0) {
+    const db = ctx.app.get?.("database");
+    if (db) {
+      const repo = new SessionEnvSelectionRepository(db);
+      const existing = await repo.asSet(ctx.sessionId);
+      await repo.setAll(ctx.sessionId, orderedEnvVarNames([...existing, ...submittedNames]));
     }
-  );
+  }
 }
 var envVarsWidget = {
   type: "env_vars",
@@ -14594,12 +14709,20 @@ var envVarsWidget = {
   paramsSchema: envVarsParamsSchema,
   submitSchema: envVarsSubmitSchema,
   buildResultMeta: (submit) => ({
-    names_submitted: Object.keys(submit.values),
+    names_submitted: orderedEnvVarNames(Object.keys(submit.values)),
+    ...submit.use_existing.length > 0 ? { names_used_existing: orderedEnvVarNames(submit.use_existing) } : {},
     scope: submit.scope
   }),
   applySubmit: applyEnvVarsSubmit,
-  buildAutoResumePrompt: (rm) => `[Agor] User submitted ${rm.names_submitted.join(", ")} (scope: ${rm.scope}). You can now retry the operation that needed ${rm.names_submitted.length === 1 ? "it" : "them"}.`,
-  buildDismissedPrompt: (params) => `[Agor] User dismissed the request for ${params.names.join(", ")}. Do not re-request immediately \u2014 ask whether to proceed without, or move on to other work.`
+  buildAutoResumePrompt: (rm) => {
+    const existing = orderedEnvVarNames(rm.names_used_existing ?? []);
+    const names = orderedEnvVarNames([...rm.names_submitted, ...existing]);
+    const savedPart = rm.names_submitted.length > 0 ? `saved ${orderedEnvVarNames(rm.names_submitted).join(", ")} (scope: ${rm.scope})` : "";
+    const existingPart = existing.length > 0 ? `used existing ${existing.join(", ")} (scope: global)` : "";
+    const action = [savedPart, existingPart].filter(Boolean).join(" and ");
+    return `[Agor] User ${action}. You can now retry the operation that needed ${names.length === 1 ? "it" : "them"}.`;
+  },
+  buildDismissedPrompt: (params) => `[Agor] User dismissed the request for ${orderedEnvVarNames(params.names).join(", ")}. Do not re-request immediately \u2014 ask whether to proceed without, or move on to other work.`
 };
 function registerEnvVarsWidget() {
   registerWidget(envVarsWidget);
@@ -14608,5 +14731,6 @@ export {
   envVarsParamsSchema,
   envVarsSubmitSchema,
   envVarsWidget,
+  normalizeEnvVarsParams,
   registerEnvVarsWidget
 };

package/dist/daemon/widgets/gateway-token/index.d.ts

@@ -0,0 +1,114 @@
+/**
+ * gateway_token widget — registry entry and registration.
+ *
+ * Concrete widget type: an admin supplies a gateway channel's platform
+ * credentials (Slack bot/app tokens, GitHub private key, Teams app password)
+ * through an inline form. The values flow browser → daemon via
+ * `POST /widgets/:widget_id/submit` and land in the channel's encrypted
+ * `config` through the gateway-channels service — never through the agent's
+ * MCP context. Setting a channel's tokens is admin-only, so `applySubmit`
+ * gates on `ROLES.ADMIN` before touching anything.
+ *
+ * See §4 + §7 of `docs/internal/in-conversation-widgets-design-2026-05-19.md`.
+ */
+import { type ChannelType, type SlackTestResult } from '@agor/core/types';
+import { z } from 'zod';
+import { type WidgetRegistryEntry } from '../registry.js';
+export declare function isSupportedGatewayTokenChannelType(channelType: string): boolean;
+/**
+ * Agent-provided params (validated when the MCP tool fires). All non-secret:
+ * the channel identity, its type/name, and the field NAMES to collect. Stored
+ * at `metadata.widget.params` on the widget message row.
+ */
+export declare const gatewayTokenParamsSchema: z.ZodObject<{
+    gatewayChannelId: z.ZodString;
+    channelType: z.ZodEnum<{
+        slack: "slack";
+        discord: "discord";
+        whatsapp: "whatsapp";
+        telegram: "telegram";
+        github: "github";
+        teams: "teams";
+    }>;
+    channelName: z.ZodString;
+    fields: z.ZodArray<z.ZodEnum<{
+        app_token: "app_token";
+        private_key: "private_key";
+        app_password: "app_password";
+        bot_token: "bot_token";
+        signing_secret: "signing_secret";
+        webhook_secret: "webhook_secret";
+    }>>;
+    reason: z.ZodString;
+}, z.core.$strict>;
+export type GatewayTokenParams = z.infer<typeof gatewayTokenParamsSchema>;
+/**
+ * Browser → daemon submit payload. Direct HTTP, never reaches the agent. The
+ * keys are constrained to the sensitive field names; the values are the raw
+ * credentials that get encrypted by the gateway-channels service.
+ */
+export declare const gatewayTokenSubmitSchema: z.ZodObject<{
+    tokens: z.ZodRecord<z.ZodEnum<{
+        app_token: "app_token";
+        private_key: "private_key";
+        app_password: "app_password";
+        bot_token: "bot_token";
+        signing_secret: "signing_secret";
+        webhook_secret: "webhook_secret";
+    }> & z.core.$partial, z.ZodString>;
+}, z.core.$strict>;
+export type GatewayTokenSubmit = z.infer<typeof gatewayTokenSubmitSchema>;
+/**
+ * Sanitized post-resolution data written to the message row and fed into the
+ * auto-resume prompt. Carries the channel identity, which fields were set, and
+ * the enable/test outcome — but NEVER a token value, prefix, length, or
+ * last-four.
+ */
+export interface GatewayTokenResultMeta {
+    channelId: string;
+    channelName: string;
+    channelType: ChannelType;
+    fieldsSet: string[];
+    enabled: boolean;
+    /**
+     * True when the tokens were saved but the channel type has no probe, so the
+     * credentials could NOT be validated and the channel was left disabled
+     * pending manual confirmation. Distinct from an enable-blocking hard failure.
+     */
+    unverified: boolean;
+    test: {
+        ok: boolean;
+        summary: string;
+    };
+}
+/**
+ * Decide whether the probe result permits enabling the channel, a `status`
+ * discriminator, and a short human summary. Three outcomes:
+ *   - `failed` (enable:false) — a hard credential failure (bad token) or an
+ *     unbuildable connector (`config` capability — malformed config).
+ *   - `unverifiable` (enable:false) — the channel type has no probe at all
+ *     (`connector` capability); tokens are saved but the channel stays disabled
+ *     until the credentials are confirmed manually, never enabled off an unrun
+ *     probe.
+ *   - `verified` (enable:true) — the probe ran and surfaced no hard failure;
+ *     the credentials are usable even if more setup remains.
+ *
+ * `appTokenExpected` is Socket-Mode / inbound intent for THIS channel (the
+ * widget collected an app_token, i.e. `getRequiredSecretFields` asked for it).
+ * When true, a missing/failed app-level token is ALSO a hard blocker: the
+ * listener requires it (`hasListeningConfig` in services/gateway.ts), so an
+ * enabled inbound channel without a working app_token could never receive
+ * messages. When false (outbound-only — send via bot_token, no listener), the
+ * Slack probe still emits an `app_token` capability failure / `appTokenValid:
+ * false` because no app token exists, but that must NOT block enabling — the
+ * channel does not use Socket Mode.
+ */
+export declare function classifyGatewayTokenTest(result: SlackTestResult, appTokenExpected: boolean): {
+    enable: boolean;
+    status: 'verified' | 'unverifiable' | 'failed';
+    summary: string;
+};
+export declare const gatewayTokenWidget: WidgetRegistryEntry<GatewayTokenParams, GatewayTokenSubmit, GatewayTokenResultMeta>;
+/** Idempotent registration helper, safe to call at every daemon boot. */
+export declare function registerGatewayTokenWidget(): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/daemon/widgets/gateway-token/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/widgets/gateway-token/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,EACL,KAAK,WAAW,EAIhB,KAAK,eAAe,EAErB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAkB,KAAK,mBAAmB,EAAwB,MAAM,gBAAgB,CAAC;AAahG,wBAAgB,kCAAkC,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAE/E;AASD;;;;GAIG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;kBA+B1B,CAAC;AAEZ,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E;;;;GAIG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;kBAY1B,CAAC;AAEZ,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E;;;;;GAKG;AACH,MAAM,WAAW,sBAAsB;IACrC,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,WAAW,CAAC;IACzB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,OAAO,EAAE,OAAO,CAAC;IACjB;;;;OAIG;IACH,UAAU,EAAE,OAAO,CAAC;IACpB,IAAI,EAAE;QAAE,EAAE,EAAE,OAAO,CAAC;QAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;CACxC;AAoCD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,eAAe,EACvB,gBAAgB,EAAE,OAAO,GACxB;IACD,MAAM,EAAE,OAAO,CAAC;IAChB,MAAM,EAAE,UAAU,GAAG,cAAc,GAAG,QAAQ,CAAC;IAC/C,OAAO,EAAE,MAAM,CAAC;CACjB,CAkDA;AAiID,eAAO,MAAM,kBAAkB,EAAE,mBAAmB,CAClD,kBAAkB,EAClB,kBAAkB,EAClB,sBAAsB,CA+CvB,CAAC;AAEF,yEAAyE;AACzE,wBAAgB,0BAA0B,IAAI,IAAI,CAEjD"}