@humwick/server 0.0.0-stage → 0.130.1

package/src/routes/agent-keep.ts

@@ -0,0 +1,27 @@
+// #3428 — set or clear an agent's keep flag (src/services/agent-keep.ts owns the operation).
+import { ValidationError } from "../db";
+import { authContextFromRequest } from "../services/auth-context";
+import { AgentKeepTargetError, parseAgentKeepArgs, setAgentKeep } from "../services/agent-keep";
+import { authAuditMetadata, authorizeRoute, dashboardAttribution, error, json, parseBody, type Handler } from "./_shared";
+import { isRecord } from "../types";
+
+export const putAgentKeep: Handler = async (req, params) => {
+  const parsed = await parseBody<unknown>(req);
+  if (!parsed.ok) return error(parsed.error, parsed.status);
+  if (!isRecord(parsed.body)) return error("keep required");
+  const denied = authorizeRoute(req, { scope: "agent:write" });
+  if (denied) return denied;
+  try {
+    const result = await setAgentKeep({
+      agentId: params.id!,
+      ...parseAgentKeepArgs(parsed.body),
+      requestedVia: "http",
+      auditMetadata: { ...authAuditMetadata(req), ...dashboardAttribution(req, parsed.body.surface) },
+    }, authContextFromRequest(req));
+    return json({ ok: true, ...result });
+  } catch (e) {
+    if (e instanceof ValidationError) return error(e.message, 400);
+    if (e instanceof AgentKeepTargetError) return error(e.message, 404);
+    throw e;
+  }
+};

package/src/routes/agent-profiles.ts

@@ -0,0 +1,169 @@
+import { PromptVersionConflictError } from "../prompt-version-errors";
+import { versionedPromptsEnabled } from "../versioned-prompts";
+import { promptActor } from "../services/prompt-version-writer";
+import { setConfigAsync } from "../config-store-write";
+import { memoryRetirementMessage } from "../memory-retirement";
+// Auto-split from routes.ts (#299). Domain: agent-profiles.
+import { ValidationError, withResolvedProvisioningAsync } from "../db";
+import { cleanString, optionalEnum } from "../validation";
+import { deleteAgentProfile, getAgentProfile, listAgentProfiles, resolveAgentProfileKey, setAgentProfile, validateAgentProfile } from "../config-store";
+import { RELAY_TOOL_GROUPS } from "../mcp";
+import { emitConfigChanged } from "../sse";
+import { error, isAdminRequest, json, normalizeConfigPathParam, parseBody, type Handler } from "./_shared";
+import { isRecord, isSpawnProvider } from "@humwick/sdk";
+import { SPAWN_PROVIDERS, type AgentProfile, type SpawnProvider } from "../types";
+import { deriveLaunchShape, v1ToCells } from "../profile-cells";
+import { computeEffectiveProfileDisposition } from "../profile-effective-survey";
+import { projectCellsHash } from "../project-trust";
+
+export const getAgentProfilesRoute: Handler = () => json(listAgentProfiles());
+
+/**
+ * The canonical tool-group catalog (#970): name + member tool names, read straight off
+ * `RELAY_TOOL_GROUPS` so the dashboard multiselect can never drift from the code registry
+ * that `visibleTools` (src/mcp/index.ts) actually enforces at tools/list time.
+ */
+export const getAgentProfileToolGroupsRoute: Handler = () =>
+  json(Object.entries(RELAY_TOOL_GROUPS).map(([name, tools]) => ({ name, tools: [...tools] })));
+
+export const getAgentProfileRoute: Handler = (_req, params) => {
+  const name = normalizeConfigPathParam(params.name, "name");
+  const profile = getAgentProfile(name);
+  return profile ? json(profile) : error(memoryRetirementMessage(name) ?? "agent profile not found", 404);
+};
+
+function hasOperatorAuthoredAssetRef(value: unknown): boolean {
+  if (!Array.isArray(value)) return false;
+  return value.some((item) => isRecord(item) && (item.source === "repo" || item.source === "inline"));
+}
+
+/** Repo/inline refs execute code from a caller-selected source. They are an
+ * operator-authored profile fact, never something a provider/component token may
+ * smuggle into its own profile PUT. */
+function containsNonOperatorAssetRefs(profile: Record<string, unknown>): boolean {
+  if (hasOperatorAuthoredAssetRef(profile.skills) || hasOperatorAuthoredAssetRef(profile.plugins)) return true;
+  const hooks = isRecord(profile.hooks) && hasOperatorAuthoredAssetRef(profile.hooks.refs);
+  if (hooks) return true;
+  const sources = isRecord(profile.sources) ? profile.sources : undefined;
+  if (!sources) return false;
+  for (const source of [sources.host, sources.project, sources.agentRelay]) {
+    if (!isRecord(source)) continue;
+    for (const cell of Object.values(source)) {
+      if (isRecord(cell) && hasOperatorAuthoredAssetRef(cell.refs)) return true;
+    }
+  }
+  return false;
+}
+
+export const getResolvedAgentProfileRoute: Handler = async (req, params) => {
+  try {
+    if (!isAdminRequest(req)) return error("system admin scope required", 403);
+    const name = normalizeConfigPathParam(params.name, "name");
+    const entry = getAgentProfile(name);
+    if (!entry) return error(memoryRetirementMessage(name) ?? "agent profile not found", 404);
+    const requestedProvider = new URL(req.url).searchParams.get("provider") ?? undefined;
+    const profileProvider = isSpawnProvider(entry.value.provider) ? entry.value.provider : undefined;
+    const provider = optionalEnum(requestedProvider, "provider", SPAWN_PROVIDERS, profileProvider ?? "codex") as SpawnProvider;
+    const profile = await withResolvedProvisioningAsync(entry.value, provider);
+    return profile ? json({ provider, profile }) : error(memoryRetirementMessage(name) ?? "agent profile not found", 404);
+  } catch (e) {
+    if (e instanceof PromptVersionConflictError) return json({ error: e.message, current: e.current }, 409);
+    if (e instanceof ValidationError) return error(e.message, 400);
+    throw e;
+  }
+};
+
+/**
+ * #1963 N12 — the live launch-preview strip's data source. Takes an UNSAVED draft profile body
+ * (the dashboard editor's in-progress state, same shape as the PUT body) and runs it through the
+ * exact same server-side pipeline a save would use, WITHOUT persisting: `validateAgentProfile`
+ * (dry-run normalize/validate — surfaces G8 base×sources contradictions as 400, same as PUT),
+ * then `v1ToCells` + `deriveLaunchShape` (src/profile-cells.ts) for the provider-neutral launch
+ * facts, `computeEffectiveProfileDisposition` (src/profile-effective-survey.ts) for the n/a/ambient
+ * dispositions that drive dimmed cells, and `projectCellsHash` (src/project-trust.ts) so the
+ * dashboard's project-cell ack checkbox can detect staleness against the SAME hash the spawn-time
+ * trust gate checks — never a client-side reimplementation of any of these.
+ *
+ * The hash MUST be computed over the same object the gate hashes at spawn time:
+ * `projectCapabilityGate` (src/project-trust.ts) hashes `profile.sources.project` as STORED,
+ * never a `v1ToCells` re-derivation — `v1ToCells` hardcodes `trust:{scope:"roots"}`, drops
+ * `review`, and hardcodes `plugins:{enabled:false}` (it's a lossy v1-migration VIEW, not the
+ * authoritative v2 record). Hashing `cells.sources.project` here would diverge from the gate's
+ * hash the moment an operator sets a non-default trust scope/review or enables project plugins,
+ * silently invalidating every ack at spawn time. Fall back to the derived view only when the
+ * draft has no stamped `sources.project` yet (nothing to ack against in that state anyway).
+ */
+export const postAgentProfilePreviewRoute: Handler = async (req) => {
+  const parsed = await parseBody<unknown>(req);
+  if (!parsed.ok) return error(parsed.error, parsed.status);
+  try {
+    if (!isAdminRequest(req)) return error("system admin scope required", 403);
+    if (!isRecord(parsed.body)) throw new ValidationError("agent profile body required");
+    const requestedProvider = new URL(req.url).searchParams.get("provider") ?? undefined;
+    const draftProvider = isSpawnProvider(parsed.body.provider) ? parsed.body.provider : undefined;
+    const provider = optionalEnum(requestedProvider, "provider", SPAWN_PROVIDERS, draftProvider ?? "claude") as SpawnProvider;
+    const name = typeof parsed.body.name === "string" ? parsed.body.name.trim() : "";
+    const normalized = validateAgentProfile(name, { ...parsed.body, name }, { allowBuiltIn: true });
+    const cells = v1ToCells(normalized, provider);
+    const launchShape = deriveLaunchShape(cells, provider);
+    const disposition = computeEffectiveProfileDisposition(normalized, provider);
+    return json({ provider, launchShape, disposition, projectCellsHash: projectCellsHash(normalized.sources?.project ?? cells.sources.project) });
+  } catch (e) {
+    if (e instanceof PromptVersionConflictError) return json({ error: e.message, current: e.current }, 409);
+    if (e instanceof ValidationError) return error(e.message, 400);
+    throw e;
+  }
+};
+
+export const putAgentProfileRoute: Handler = async (req, params) => {
+  const parsed = await parseBody<unknown>(req);
+  if (!parsed.ok) return error(parsed.error, parsed.status);
+  try {
+    if (!isRecord(parsed.body)) throw new ValidationError("agent profile body required");
+    // #2791 — PUT addresses the stored key: /qa updates "QA" (preserving its case), and
+    // /WORKER applies a built-in override to "worker". Genuine creates keep the typed case.
+    const requestedName = normalizeConfigPathParam(params.name, "name");
+    const name = resolveAgentProfileKey(requestedName) ?? requestedName;
+    if (containsNonOperatorAssetRefs(parsed.body) && !isAdminRequest(req)) {
+      return error("source repo/inline asset refs may only be authored by an operator", 403);
+    }
+    // #1963 N10 G8 (base × sources precedence, "never silently pick") is enforced in the config-store
+    // validator `assertProfileSourcesMatchInstructions`, the single write chokepoint every path funnels
+    // through — the profile route here, the generic /api/config PUT, and setAgentProfile — so it cannot
+    // be bypassed and a contradiction surfaces as a ValidationError → 400 below.
+    const updatedBy = versionedPromptsEnabled() ? promptActor(req) : cleanString(parsed.body.updatedBy, "updatedBy", { max: 200 });
+    const existing = getAgentProfile(name);
+    if (versionedPromptsEnabled() && ["worker", "coordinator"].includes(name) && existing?.value.builtIn && isAdminRequest(req)) {
+      await setConfigAsync("agent-profile-override", name, { ...parsed.body, name }, updatedBy);
+      const saved = getAgentProfile(name)!;
+      emitConfigChanged(saved.namespace, saved.key, saved.version);
+      return json(saved);
+    }
+    const profile = existing?.value.builtIn && isAdminRequest(req)
+      ? setAgentProfile({ ...parsed.body, name } as AgentProfile, updatedBy, { overrideBuiltIn: true })
+      : setAgentProfile({ ...parsed.body, name } as AgentProfile, updatedBy);
+    emitConfigChanged(profile.namespace, profile.key, profile.version);
+    return json(profile, existing ? 200 : profile.version === 1 ? 201 : 200);
+  } catch (e) {
+    if (e instanceof PromptVersionConflictError) return json({ error: e.message, current: e.current }, 409);
+    if (e instanceof ValidationError) return error(e.message, 400);
+    throw e;
+  }
+};
+
+export const deleteAgentProfileRoute: Handler = (req, params) => {
+  try {
+    const name = normalizeConfigPathParam(params.name, "name");
+    const existing = getAgentProfile(name);
+    if (!existing) return error(memoryRetirementMessage(name) ?? "agent profile not found", 404);
+    const updatedBy = versionedPromptsEnabled() ? promptActor(req) : cleanString(new URL(req.url).searchParams.get("updatedBy") ?? undefined, "updatedBy", { max: 200 });
+    if (existing.value.builtIn && !isAdminRequest(req)) return error("built-in agent profiles are managed by Relay", 400);
+    deleteAgentProfile(name, updatedBy, { resetBuiltInOverride: existing.value.builtIn });
+    emitConfigChanged(existing.namespace, existing.key, existing.version + 1);
+    return json({ ok: true });
+  } catch (e) {
+    if (e instanceof PromptVersionConflictError) return json({ error: e.message, current: e.current }, 409);
+    if (e instanceof ValidationError) return error(e.message, 400);
+    throw e;
+  }
+};

package/src/routes/agent-reporting.ts

@@ -0,0 +1,19 @@
+import { setAgentReportVerbosity } from "../services/agent-reporting";
+import { authContextFromRequest } from "../services/auth-context";
+import { ShutdownAuthError, ShutdownTargetError } from "../services/shutdown-agent";
+import { ValidationError } from "../db";
+import { cleanString } from "../validation";
+import { authorizeAgentRoute, authorizeRoute, error, json } from "./_shared";
+
+export async function postAgentReportingAction(req: Request, agentId: string, body: Record<string, unknown>): Promise<Response> {
+  const denied = authorizeAgentRoute(req, agentId, "drive") ?? authorizeRoute(req, { scope: "agent:write", resource: { agentId } });
+  if (denied) return denied;
+  try {
+    return json({ ok: true, ...await setAgentReportVerbosity({ agentId, reportVerbosity: body.reportVerbosity, reason: cleanString(body.reason, "reason", { max: 500 }), requestedVia: "http" }, authContextFromRequest(req)) });
+  } catch (e) {
+    if (e instanceof ValidationError) return error(e.message, 400);
+    if (e instanceof ShutdownAuthError) return error(e.message, 403);
+    if (e instanceof ShutdownTargetError) return error(e.message, 404);
+    throw e;
+  }
+}

package/src/routes/agent-self-effort.ts

@@ -0,0 +1,51 @@
+// #2966 — read and set whether a running agent may change its own effort, and up to which ceiling.
+import { ValidationError, getAgent } from "../db";
+import { cleanString } from "../validation";
+import { authContextFromRequest } from "../services/auth-context";
+import { AgentActionTargetError } from "../services/agent-action";
+import { spawnSelfEffortPolicy } from "../services/self-effort";
+import { grantSelfEffort } from "../services/self-effort-grant";
+import { ShutdownAuthError, ShutdownTargetError } from "../services/shutdown-agent";
+import { authAuditMetadata, authorizeAgentRoute, authorizeRoute, dashboardAttribution, error, json, metaString, parseBody, requestUserAddress, type Handler } from "./_shared";
+import { isRecord } from "../types";
+
+export const getAgentSelfEffort: Handler = (req, params) => {
+  const agent = getAgent(params.id!);
+  if (!agent) return error("agent not found", 404);
+  const denied = authorizeAgentRoute(req, agent.id, "view");
+  if (denied) return denied;
+  return json({ agentId: agent.id, selfEffort: spawnSelfEffortPolicy(agent) ?? null });
+};
+
+export const putAgentSelfEffort: Handler = async (req, params) => {
+  const parsed = await parseBody<unknown>(req);
+  if (!parsed.ok) return error(parsed.error, parsed.status);
+  if (!isRecord(parsed.body)) return error("selfEffort required");
+  const body = parsed.body;
+  const agent = getAgent(params.id!);
+  if (!agent) return error("agent not found", 404);
+  const driveDenied = authorizeAgentRoute(req, agent.id, "drive");
+  if (driveDenied) return driveDenied;
+  const denied = authorizeRoute(req, {
+    scope: "agent:write",
+    resource: { agentId: agent.id, policyName: metaString(agent.meta, "policyName"), spawnRequestId: metaString(agent.meta, "spawnRequestId") },
+  });
+  if (denied) return denied;
+  try {
+    const result = await grantSelfEffort({
+      agentId: agent.id,
+      selfEffort: typeof body.selfEffort === "boolean" ? body.selfEffort : undefined,
+      selfEffortCeiling: cleanString(body.selfEffortCeiling, "selfEffortCeiling", { max: 32 }),
+      requestedVia: "http",
+      requestedBy: "dashboard",
+      requestedByUser: requestUserAddress(req),
+      auditMetadata: { ...authAuditMetadata(req), ...dashboardAttribution(req, body.surface) },
+    }, authContextFromRequest(req));
+    return json({ ok: true, agentId: agent.id, selfEffort: result.selfEffort, commandId: result.command.id });
+  } catch (e) {
+    if (e instanceof ValidationError) return error(e.message, 400);
+    if (e instanceof ShutdownAuthError) return error(e.message, 403);
+    if (e instanceof AgentActionTargetError || e instanceof ShutdownTargetError) return error(e.message, 404);
+    throw e;
+  }
+};