@solongate/proxy 0.83.58 → 0.83.60

package/dist/api-client/client.d.ts

@@ -58,11 +58,25 @@ export declare function isAuthenticated(): boolean;
  */
 export declare function resolveCredentials(apiUrlOverride?: string): Credentials;
 export interface RequestOptions {
-    query?: Record<string, string | number | boolean | undefined>;
+    /**
+     * Query parameters. An ARRAY is sent as the same key repeated, not as a
+     * comma-joined value — the fleet filters (`group`, `who`) are repeated
+     * parameters on the API side, and a joined one reads as a single group whose
+     * name contains a comma.
+     */
+    query?: Record<string, string | number | boolean | string[] | undefined>;
     body?: unknown;
     timeoutMs?: number;
     /** Override api URL for this request (rarely needed). */
     apiUrl?: string;
+    /**
+     * Return the response body as TEXT rather than parsing it as JSON.
+     *
+     * For the routes that answer with a document — the report download is
+     * markdown or CSV. Without this the body parses to undefined and the caller
+     * gets an empty file with no error to explain it.
+     */
+    raw?: boolean;
 }
 /**
  * Typed request against the v1 API. Returns the parsed JSON body (as T) for 2xx

package/dist/api-client/fleet.d.ts

@@ -0,0 +1,163 @@
+export interface FleetMember {
+    id: string;
+    guest_user_id: string;
+    email: string;
+    status: string;
+    group: string;
+    policy_id: string;
+    top_agent: string;
+    variant_id: string;
+    created_at: string;
+    accepted_at: string;
+}
+export interface FleetOverview {
+    host: boolean;
+    seats: number;
+    used: number;
+    host_group: string;
+    host_top_agent: string;
+    invitations: FleetMember[];
+}
+export interface FleetGroup {
+    name: string;
+    members: number;
+    color: string;
+    policy_id: string;
+}
+export interface FleetPerson {
+    guest_user_id: string;
+    email: string;
+    role: string;
+    group: string;
+    calls: number;
+    denied: number;
+    sessions: number;
+    last_at: string;
+}
+export interface FleetCount {
+    name: string;
+    calls: number;
+    denied: number;
+}
+export interface FleetSummary {
+    developers: number;
+    totals: {
+        calls: number;
+        allowed: number;
+        denied: number;
+        sessions: number;
+    };
+    agents: FleetCount[];
+    tools: FleetCount[];
+    by_hour: number[];
+    people: FleetPerson[];
+    groups: FleetGroup[];
+    range: string;
+}
+export interface FleetReport {
+    span: string;
+    title: string;
+    headline: string;
+    from: number;
+    to: number;
+    totals: {
+        calls: number;
+        allowed: number;
+        denied: number;
+        sessions: number;
+        agents: number;
+        tools: number;
+        prev_calls: number;
+        prev_denied: number;
+    };
+    top_denies: FleetCount[];
+    top_tools: FleetCount[];
+    top_agents: FleetCount[];
+    people: Array<{
+        user_id: string;
+        label: string;
+        calls: number;
+        denied: number;
+        sessions: number;
+    }>;
+}
+export interface ReportSchedule {
+    endMinute: number;
+    day: boolean;
+    week: boolean;
+    month: boolean;
+    weekday: number;
+    emails: string[];
+    telegram: string[];
+}
+/** Who is on the fleet, and every invitation's state. */
+export declare function overview(): Promise<FleetOverview>;
+/** Everybody's numbers at once. `range` is the same vocabulary the card uses. */
+export declare function summary(opts?: {
+    range?: string;
+    group?: string[];
+    who?: string[];
+    agent?: string;
+}): Promise<FleetSummary>;
+/** The groups themselves, including the empty ones. */
+export declare function groups(): Promise<{
+    groups: FleetGroup[];
+}>;
+export declare function createGroup(name: string, color?: string): Promise<unknown>;
+export declare function renameGroup(name: string, newName: string): Promise<unknown>;
+export declare function setGroupColor(name: string, color: string): Promise<unknown>;
+export declare function deleteGroup(name: string): Promise<unknown>;
+/**
+ * Which policy a whole group runs.
+ *
+ * This is what a fleet is for; everything else about a group is filing. An
+ * empty id means the group names none and its members fall back to the
+ * project's own choice.
+ */
+export declare function setGroupPolicy(name: string, policyId: string): Promise<unknown>;
+/** The per-person exception to a group's policy. Empty clears it. */
+export declare function setUserPolicy(ids: string[], policyId: string): Promise<unknown>;
+/** File people under a label. An empty group unfiles them. */
+export declare function assignGroup(ids: string[], group: string): Promise<unknown>;
+export declare function invite(email: string): Promise<unknown>;
+export declare function revoke(id: string): Promise<unknown>;
+/** One person, in full. `guest` is an account id, or "self" for the host. */
+export declare function analytics(guest: string): Promise<Record<string, unknown>>;
+/** One person's recent calls. */
+export declare function activity(guest: string, limit?: number): Promise<Record<string, unknown>>;
+/** A span of the fleet's history, summarised. */
+export declare function report(span?: 'day' | 'week' | 'month'): Promise<FleetReport>;
+/** The same report, as the file the dashboard offers. */
+export declare function reportDownload(span: 'day' | 'week' | 'month', format?: 'md' | 'csv'): Promise<string>;
+export declare function sendReport(span?: 'day' | 'week' | 'month'): Promise<{
+    emails: number;
+    telegram: number;
+}>;
+export declare function reportSchedule(): Promise<{
+    schedule: ReportSchedule;
+    next: number;
+}>;
+export declare function setReportSchedule(schedule: Partial<ReportSchedule>): Promise<{
+    schedule: ReportSchedule;
+    next: number;
+}>;
+export interface FleetStreamRow {
+    id: string;
+    user_id: string;
+    who: string;
+    session_id: string;
+    tool: string;
+    agent: string;
+    decision: string;
+    reason: string;
+    created_at: number;
+}
+/**
+ * The fleet's calls as they land, with the person on each one.
+ *
+ * Separate from activity() because that one is about a person and this is about
+ * a moment. Same table, opposite question.
+ */
+export declare function stream(limit?: number): Promise<{
+    calls: FleetStreamRow[];
+}>;

package/dist/api-client/index.d.ts

@@ -13,6 +13,7 @@ import * as audit from './audit.js';
 import * as agents from './agents.js';
 import * as keys from './keys.js';
 import * as mcp from './mcp.js';
+import * as fleet from './fleet.js';
 export declare const api: {
     auth: typeof auth;
     policies: typeof policies;
@@ -22,4 +23,5 @@ export declare const api: {
     agents: typeof agents;
     keys: typeof keys;
     mcp: typeof mcp;
+    fleet: typeof fleet;
 };

package/dist/commands/index.js

@@ -152,8 +152,8 @@ function readCodexHooksFile(path) {
       continue;
     }
     if (k === "hooks" && v && typeof v === "object") {
-      for (const [ev, groups] of Object.entries(v)) {
-        if (Array.isArray(groups)) out2.hooks[ev] = groups;
+      for (const [ev, groups2] of Object.entries(v)) {
+        if (Array.isArray(groups2)) out2.hooks[ev] = groups2;
       }
       continue;
     }
@@ -299,6 +299,10 @@ function buildUrl(base, path, query) {
   if (query) {
     for (const [k, v] of Object.entries(query)) {
       if (v === void 0) continue;
+      if (Array.isArray(v)) {
+        for (const one of v) url.searchParams.append(k, one);
+        continue;
+      }
       url.searchParams.set(k, String(v));
     }
   }
@@ -358,6 +362,7 @@ async function request(method, path, opts = {}) {
     if (res.status >= 500) throw new ApiError(res.status, "SERVER_ERROR", text || "SolonGate API had a problem (server error). Please try again in a moment.");
     throw new ApiError(res.status, "ERROR", text || res.statusText || `HTTP ${res.status}`);
   }
+  if (opts.raw) return text;
   return json;
 }
 
@@ -598,8 +603,100 @@ function list4() {
   return request("GET", "/mcp-servers");
 }
 
+// src/api-client/fleet.ts
+var fleet_exports = {};
+__export(fleet_exports, {
+  activity: () => activity,
+  analytics: () => analytics,
+  assignGroup: () => assignGroup,
+  createGroup: () => createGroup,
+  deleteGroup: () => deleteGroup,
+  groups: () => groups,
+  invite: () => invite,
+  overview: () => overview,
+  renameGroup: () => renameGroup,
+  report: () => report,
+  reportDownload: () => reportDownload,
+  reportSchedule: () => reportSchedule,
+  revoke: () => revoke2,
+  sendReport: () => sendReport,
+  setGroupColor: () => setGroupColor,
+  setGroupPolicy: () => setGroupPolicy,
+  setReportSchedule: () => setReportSchedule,
+  setUserPolicy: () => setUserPolicy,
+  stream: () => stream,
+  summary: () => summary
+});
+function overview() {
+  return request("GET", "/fleet");
+}
+function summary(opts = {}) {
+  const query = {};
+  if (opts.range) query.range = opts.range;
+  if (opts.group?.length) query.group = opts.group;
+  if (opts.who?.length) query.who = opts.who;
+  if (opts.agent) query.agent = opts.agent;
+  return request("GET", "/fleet/summary", { query });
+}
+function groups() {
+  return request("GET", "/fleet/groups");
+}
+function createGroup(name, color) {
+  return request("POST", "/fleet/groups", { body: { name, color } });
+}
+function renameGroup(name, newName) {
+  return request("POST", "/fleet/groups/rename", { body: { name, new_name: newName } });
+}
+function setGroupColor(name, color) {
+  return request("POST", "/fleet/groups/color", { body: { name, color } });
+}
+function deleteGroup(name) {
+  return request("POST", "/fleet/groups/delete", { body: { name } });
+}
+function setGroupPolicy(name, policyId) {
+  return request("POST", "/fleet/groups/policy", { body: { name, policy_id: policyId } });
+}
+function setUserPolicy(ids, policyId) {
+  return request("POST", "/fleet/policy", { body: { ids, policy_id: policyId } });
+}
+function assignGroup(ids, group) {
+  return request("POST", "/fleet/group", { body: { ids, group } });
+}
+function invite(email) {
+  return request("POST", "/fleet/invitations", { body: { email } });
+}
+function revoke2(id) {
+  return request("DELETE", `/fleet/invitations/${encodeURIComponent(id)}`);
+}
+function analytics(guest) {
+  return request("GET", "/fleet/analytics", { query: { guest } });
+}
+function activity(guest, limit) {
+  const query = { guest };
+  if (limit) query.limit = limit;
+  return request("GET", "/fleet/activity", { query });
+}
+function report(span = "day") {
+  return request("GET", "/fleet/report", { query: { span } });
+}
+function reportDownload(span, format = "md") {
+  return request("GET", "/fleet/report/download", { query: { span, format }, raw: true });
+}
+function sendReport(span = "day") {
+  return request("POST", "/fleet/report/send", { query: { span }, body: {} });
+}
+function reportSchedule() {
+  return request("GET", "/settings/reports");
+}
+function setReportSchedule(schedule) {
+  return request("PUT", "/settings/reports", { body: schedule });
+}
+function stream(limit = 60) {
+  return request("GET", "/fleet/stream", { query: { limit } });
+}
+
 // src/api-client/index.ts
-var api = { auth: auth_exports, policies: policies_exports, settings: settings_exports, stats: stats_exports, audit: audit_exports, agents: agents_exports, keys: keys_exports, mcp: mcp_exports };
+var api = { auth: auth_exports, policies: policies_exports, settings: settings_exports, stats: stats_exports, audit: audit_exports, agents: agents_exports, keys: keys_exports, mcp: mcp_exports, fleet: fleet_exports };
 
 // src/cli-utils.ts
 var c = {