@frankieai/server 0.1.1 → 0.2.0

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { Hono } from 'hono';
-import { FrankieConfig, AuthConfig, ChatAttachment, FrankieServerEvent, McpServerConfig, ToolPolicy, ApiSourceConfig } from '@frankieai/core';
+import { FrankieConfig, AuthConfig, WorkspaceSkill, ChatAttachment, FrankieServerEvent, McpServerConfig, ToolPolicy, ApiSourceConfig } from '@frankieai/core';
 import { AgentMessage, AgentTool } from '@earendil-works/pi-agent-core';
 import { JWTPayload } from 'jose';
 import { Models, Model, Api } from '@earendil-works/pi-ai';
@@ -42,8 +42,18 @@ interface RateLimiter {
 declare class MemoryRateLimiter implements RateLimiter {
     private readonly hits;
     private lastSweep;
+    /**
+     * The longest window any caller has asked for. The sweep horizon has to cover
+     * it, or sweeping would discard hits the window still counts.
+     */
+    private maxWindowMs;
     take(key: string, limit: number, windowSeconds: number): Promise<boolean>;
-    /** Drop empty buckets occasionally so a long-lived process does not grow. */
+    /**
+     * Trim stale hits and drop empty buckets occasionally, so a long-lived process
+     * does not grow. The horizon tracks the longest window in use rather than a
+     * fixed hour: a shorter one would drop timestamps that window still counts,
+     * silently handing the caller a fresh budget mid-window.
+     */
     private sweep;
 }
 
@@ -105,29 +115,29 @@ interface ChatSession {
     id: string;
     tenantId: string;
     user: VerifiedUser;
-    /**
-     * The raw host-signed token, kept only so it can be forwarded to MCP servers
-     * the tenant has explicitly opted into. Never written to disk or logs.
-     */
+    /** Raw host-signed token, forwarded only to tenant tools that explicitly opt in. */
     userToken?: string;
-    /** Page context the host passed at session creation. */
+    origin?: string;
     context: Record<string, string | number | boolean | null>;
-    /**
-     * The conversation transcript. Frankie owns it outright — the agent loop is
-     * stateless between turns and is handed this array each time — which is what
-     * makes a session portable to a shared store, and exportable.
-     */
+    /** Agent transcript used to continue the model conversation on the server. */
     messages: AgentMessage[];
+    /** UI transcript kept separately so the exact rendered chat can sync across devices. */
+    clientMessages?: unknown[];
+    /** User-editable title, otherwise derived from the first user message. */
+    title?: string;
     createdAt: number;
     lastActiveAt: number;
     messageCount: number;
     costUsd: number;
-    /** Set while a turn is in flight, so a second concurrent turn is rejected. */
     busy: boolean;
 }
 interface SessionStore {
     create(session: ChatSession): Promise<void>;
     get(id: string): Promise<ChatSession | undefined>;
+    /** List one user's conversations for a tenant, newest first. */
+    listByUser(tenantId: string, userId: string): Promise<ChatSession[]>;
+    /** Workspace-owner history view. This is only exposed through the authenticated control plane. */
+    listByTenant(tenantId: string): Promise<ChatSession[]>;
     update(id: string, patch: Partial<ChatSession>): Promise<void>;
     delete(id: string): Promise<void>;
 }
@@ -137,6 +147,8 @@ declare class MemorySessionStore implements SessionStore {
     constructor(ttlMs?: number);
     create(session: ChatSession): Promise<void>;
     get(id: string): Promise<ChatSession | undefined>;
+    listByUser(tenantId: string, userId: string): Promise<ChatSession[]>;
+    listByTenant(tenantId: string): Promise<ChatSession[]>;
     update(id: string, patch: Partial<ChatSession>): Promise<void>;
     delete(id: string): Promise<void>;
     private evictExpired;
@@ -187,13 +199,18 @@ interface TenantStore {
     byPublishableKey(key: string): Promise<ResolvedConfig | null>;
 }
 /**
- * Turns a `TenantStore` into ready-to-serve `TenantRuntime`s, caching each
- * tenant's `TokenService` and resolved model so the model catalogue is walked
- * once per tenant rather than once per request.
+ * Turns a `TenantStore` into ready-to-serve `TenantRuntime`s.
+ *
+ * Config is read from the store on every resolve, so a change made through the
+ * control plane — a new connection, a widened tool policy, a theme — is picked
+ * up on the very next request rather than being pinned to whatever was cached
+ * when the tenant was first seen. Only the expensive part, walking the provider
+ * catalogue to resolve a model, is memoised (keyed by the model settings), so
+ * the hot path stays cheap without ever serving a stale config.
  */
 declare class TenantRegistry {
     private readonly store;
-    private readonly cache;
+    private readonly modelCache;
     constructor(store: TenantStore);
     /**
      * A registry over exactly one tenant. Builds the runtime eagerly so an
@@ -209,8 +226,6 @@ declare class TenantRegistry {
      * whole fleet.
      */
     resolve(publishableKey: string): Promise<TenantRuntime | null>;
-    /** Drop a cached runtime so the next request rebuilds it from the store. */
-    evict(publishableKey: string): void;
 }
 /** A store over a single resolved config — the self-hosted, one-tenant case. */
 declare class SingleTenantStore implements TenantStore {
@@ -263,18 +278,34 @@ declare function createMcpHostApp(options: McpHostOptions): Hono;
  * customer's backend signs with, and the session-token secret) live here for a
  * self-hosted start; a hosted deployment swaps this file store for a vault.
  */
+interface RepositoryInstallRecord {
+    repository: string;
+    status: "installing" | "submitted" | "failed";
+    runId?: string;
+    pullRequestUrl?: string;
+    requiresJwtSecret: boolean;
+    failureMessage?: string;
+    updatedAt: string;
+}
 interface TenantRecord {
+    skillHistory?: FrankieConfig["skills"];
     id: string;
     /** Who owns this tenant — the dashboard user's stable id (e.g. "github:42"). */
     ownerId?: string;
     config: FrankieConfig;
     jwtSecret?: string;
     sessionSecret: string;
+    /** When true, the workspace is protected: it cannot be deleted until unlocked. */
+    locked?: boolean;
+    /** Durable repository-install state surfaced in the dashboard and setup chat. */
+    repositoryInstall?: RepositoryInstallRecord;
     createdAt: string;
     updatedAt: string;
 }
 /** A tenant record with its secrets stripped — safe to return from the API. */
 interface PublicTenant {
+    skillHistory: FrankieConfig["skills"];
+    skills: TenantRecord["config"]["skills"];
     id: string;
     ownerId?: string;
     name: string;
@@ -284,6 +315,38 @@ interface PublicTenant {
     connection: "knowledge" | "mcp" | "openapi";
     mcpServers: string[];
     apis: string[];
+    /** Full connection detail so the dashboard can show and pre-fill what's configured. */
+    connections: Array<{
+        kind: "mcp" | "openapi";
+        name: string;
+        /** OpenAPI spec URL/path. */
+        spec?: string;
+        /** MCP server URL. */
+        url?: string;
+        baseUrl?: string;
+        methods?: string[];
+        capabilities?: Array<{
+            operationId: string;
+            method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+            path: string;
+            summary?: string;
+        }>;
+        discoveredTools?: Array<{
+            name: string;
+            description?: string;
+        }>;
+        selectedTools?: string[];
+        exposeAsMcp?: boolean;
+        forwardsToken: boolean;
+        /** Whether this source is currently enabled for chat. */
+        enabled: boolean;
+        /** Configuration health, not a simulated runtime probe. */
+        status: "ready" | "configured" | "needs_attention";
+    }>;
+    /** Protected from deletion until unlocked. */
+    locked: boolean;
+    /** A submitted or in-progress SDK installation for this workspace. */
+    repositoryInstall?: RepositoryInstallRecord;
     /** The customer's brand theme for the widget, so the dashboard can edit it. */
     theme: TenantRecord["config"]["theme"];
     /** Opt-in chat capabilities (attachments, model picker) for the dashboard to edit. */
@@ -292,6 +355,22 @@ interface PublicTenant {
     updatedAt: string;
 }
 declare function toPublicTenant(record: TenantRecord): PublicTenant;
+/**
+ * A member of an org. The org is identified by its owner's id (e.g. "github:42"),
+ * and members are named by their GitHub login (lowercased) so they can be invited
+ * before they've ever signed in. `admin`s can manage members; `member`s can
+ * manage the org's workspaces but not its people. The owner is always an admin
+ * and is never stored here.
+ */
+interface MembershipRecord {
+    /** The org's owner id, e.g. "github:42". */
+    org: string;
+    /** The member's GitHub login, lowercased. */
+    login: string;
+    role: "admin" | "member";
+    invitedBy?: string;
+    createdAt: string;
+}
 /**
  * A `TenantStore` the control plane can also write to and list. The data plane
  * only needs `byPublishableKey`; the control plane needs the rest. Both the
@@ -299,9 +378,20 @@ declare function toPublicTenant(record: TenantRecord): PublicTenant;
  * against the interface.
  */
 interface ControlStore extends TenantStore {
+    compareAndSwap(previous: TenantRecord, next: TenantRecord): Promise<boolean>;
     list(ownerId?: string): Promise<TenantRecord[]>;
     get(id: string): Promise<TenantRecord | null>;
     put(record: TenantRecord): Promise<void>;
+    /** Remove a tenant for good. A no-op if it does not exist. */
+    delete(id: string): Promise<void>;
+    /** All members of the org owned by `org`. */
+    listMembers(org: string): Promise<MembershipRecord[]>;
+    /** Add or update a member. */
+    putMember(member: MembershipRecord): Promise<void>;
+    /** Remove a member from an org. A no-op if absent. */
+    deleteMember(org: string, login: string): Promise<void>;
+    /** Every org membership held by a given login, across all orgs. */
+    membershipsForLogin(login: string): Promise<MembershipRecord[]>;
 }
 /**
  * The control plane's persistence, and at the same time a `TenantStore` the
@@ -317,19 +407,28 @@ declare class FileTenantStore implements ControlStore {
     private readonly env;
     private index;
     private byId;
+    private members;
     private loaded;
+    private static memberKey;
     constructor(options: {
         dir: string;
         providerKeyEnv?: string;
         env?: NodeJS.ProcessEnv;
     });
     private load;
+    private persistMembers;
+    listMembers(org: string): Promise<MembershipRecord[]>;
+    putMember(member: MembershipRecord): Promise<void>;
+    deleteMember(org: string, login: string): Promise<void>;
+    membershipsForLogin(login: string): Promise<MembershipRecord[]>;
     private remember;
     byPublishableKey(key: string): Promise<ResolvedConfig | null>;
     /** All tenants, or — when an owner is given — only that owner's. */
     list(ownerId?: string): Promise<TenantRecord[]>;
     get(id: string): Promise<TenantRecord | null>;
     put(record: TenantRecord): Promise<void>;
+    compareAndSwap(previous: TenantRecord, next: TenantRecord): Promise<boolean>;
+    delete(id: string): Promise<void>;
 }
 
 /**
@@ -353,6 +452,7 @@ interface Queryable {
  * read time and never written to the row.
  */
 declare class PostgresTenantStore implements ControlStore {
+    private readonly snapshots;
     private readonly db;
     private readonly providerKeyEnv;
     private readonly env;
@@ -370,11 +470,18 @@ declare class PostgresTenantStore implements ControlStore {
     private ensureReady;
     /** Create the table if it isn't there yet. Safe to call repeatedly. */
     init(): Promise<void>;
+    private memberRow;
+    listMembers(org: string): Promise<MembershipRecord[]>;
+    putMember(member: MembershipRecord): Promise<void>;
+    deleteMember(org: string, login: string): Promise<void>;
+    membershipsForLogin(login: string): Promise<MembershipRecord[]>;
     private parse;
     byPublishableKey(key: string): Promise<ResolvedConfig | null>;
     list(ownerId?: string): Promise<TenantRecord[]>;
     get(id: string): Promise<TenantRecord | null>;
     put(record: TenantRecord): Promise<void>;
+    delete(id: string): Promise<void>;
+    compareAndSwap(previous: TenantRecord, next: TenantRecord): Promise<boolean>;
 }
 
 interface ResolvedStore {
@@ -405,13 +512,8 @@ declare function resolveStores(env?: NodeJS.ProcessEnv): Promise<ResolvedStores>
 declare function resolveTenantStore(env?: NodeJS.ProcessEnv): Promise<ResolvedStore>;
 
 /**
- * A `SessionStore` backed by Postgres, so a user's chat history survives a
- * restart and is shared across instances — the hosted default. The whole
- * `ChatSession` (transcript included) is stored as one JSON row keyed by id.
- *
- * A customer who would rather keep transcripts in their own store implements
- * `SessionStore` against it and passes it to `createFrankieApp` — this class is
- * just the batteries-included option.
+ * Hosted session + conversation store. Transcript and UI metadata live together
+ * in Postgres, making a signed-in user's chats available from any device.
  */
 declare class PostgresSessionStore implements SessionStore {
     private readonly db;
@@ -421,17 +523,28 @@ declare class PostgresSessionStore implements SessionStore {
         db: Queryable;
         ttlMs?: number;
     });
-    /** Create the table on first use, once — lazy, so boot never blocks on the DB. */
     private ensureReady;
     init(): Promise<void>;
     create(session: ChatSession): Promise<void>;
     get(id: string): Promise<ChatSession | undefined>;
+    listByUser(tenantId: string, userId: string): Promise<ChatSession[]>;
+    listByTenant(tenantId: string): Promise<ChatSession[]>;
     update(id: string, patch: Partial<ChatSession>): Promise<void>;
     delete(id: string): Promise<void>;
 }
 
+interface SkillGenerationInput {
+    goal: string;
+    tools: string[];
+    instructions?: string;
+}
+declare function generateSkill(resolved: ResolvedConfig, input: SkillGenerationInput): Promise<WorkspaceSkill>;
+
 interface ControlOptions {
+    generateSkill?: typeof generateSkill;
     store: ControlStore;
+    /** Durable session store shared with the data plane when Postgres is configured. */
+    sessions?: SessionStore;
     /** Bearer token that gates the admin API. A stand-in for real user auth. */
     adminToken?: string;
     logger?: (event: Record<string, unknown>) => void;
@@ -548,6 +661,8 @@ interface CollectToolsOptions {
     config: FrankieConfig;
     session: ChatSession;
     fetchImpl?: typeof fetch;
+    /** Base URL of the account API for the built-in workspaceAdmin tools. */
+    accountApiUrl?: string;
     onWarning?: (message: string, detail: Record<string, unknown>) => void;
 }
 interface CollectedTools {
@@ -594,6 +709,6 @@ declare function buildForwardedHeaders(source: ForwardingConfig, session: ChatSe
  * configured. Host-supplied page context is fenced off as data: it comes from
  * a web page and must never be able to redirect the agent.
  */
-declare function buildSystemPrompt(config: FrankieConfig, session: ChatSession): string;
+declare function buildSystemPrompt(config: FrankieConfig, session: ChatSession, availableTools?: string[]): string;
 
 export { API_TOOL_PREFIX, type ApiToolSet, AuthError, type BuildApiToolsOptions, type ChatSession, type CollectToolsOptions, type CollectedTools, ConfigError, type ConnectMcpOptions, type ControlOptions, type ControlStore, type CreateAppOptions, FileTenantStore, type ForwardingConfig, MCP_TOOL_PREFIX, type McpConnection, type McpHostOptions, MemoryRateLimiter, MemorySessionStore, MemoryTenantStore, ModelResolutionError, OpenApiError, PostgresSessionStore, PostgresTenantStore, type PublicTenant, type Queryable, type RateLimiter, type ResolvedConfig, type ResolvedModel, type ResolvedStore, type ResolvedStores, type RunTurnParams, type SessionStore, SingleTenantStore, type TenantRecord, TenantRegistry, type TenantRuntime, type TenantStore, TokenService, type VerifiedUser, anonymousUser, applyEnvOverrides, buildApiTools, buildForwardedHeaders, buildSystemPrompt, collectTools, connectMcpTools, createControlApp, createFrankieApp, createMcpHostApp, isOriginAllowed, loadConfigFromFile, loadResolvedConfig, loadSpec, matchPath, modelHasApi, newSessionId, resolveModel, resolveSecrets, resolveStores, resolveTenantStore, runTurn, safeEqual, toPublicTenant };

package/dist/index.js

@@ -1,48 +1,48 @@
 import {
   createControlApp
-} from "./chunk-S7OCXWEP.js";
+} from "./chunk-CYWTCM2O.js";
 import {
-  API_TOOL_PREFIX,
   ConfigError,
-  MCP_TOOL_PREFIX,
-  MemoryRateLimiter,
   MemoryTenantStore,
-  ModelResolutionError,
-  OpenApiError,
   SingleTenantStore,
   TenantRegistry,
   applyEnvOverrides,
-  buildApiTools,
-  buildForwardedHeaders,
   buildSystemPrompt,
   collectTools,
-  connectMcpTools,
   createFrankieApp,
   createMcpHostApp,
   loadConfigFromFile,
   loadResolvedConfig,
-  loadSpec,
-  matchPath,
-  modelHasApi,
-  resolveModel,
   resolveSecrets,
   runTurn
-} from "./chunk-UUOTMDWW.js";
+} from "./chunk-BA3FZ7JH.js";
 import {
+  API_TOOL_PREFIX,
   AuthError,
   FileTenantStore,
+  MCP_TOOL_PREFIX,
+  MemoryRateLimiter,
   MemorySessionStore,
+  ModelResolutionError,
+  OpenApiError,
   PostgresSessionStore,
   PostgresTenantStore,
   TokenService,
   anonymousUser,
+  buildApiTools,
+  buildForwardedHeaders,
+  connectMcpTools,
   isOriginAllowed,
+  loadSpec,
+  matchPath,
+  modelHasApi,
   newSessionId,
+  resolveModel,
   resolveStores,
   resolveTenantStore,
   safeEqual,
   toPublicTenant
-} from "./chunk-F227CSY3.js";
+} from "./chunk-R5XGMQR4.js";
 export {
   API_TOOL_PREFIX,
   AuthError,

package/dist/server.js

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 import {
   ConfigError,
-  ModelResolutionError,
   createFrankieApp,
   loadResolvedConfig
-} from "./chunk-UUOTMDWW.js";
+} from "./chunk-BA3FZ7JH.js";
 import {
+  ModelResolutionError,
   resolveStores
-} from "./chunk-F227CSY3.js";
+} from "./chunk-R5XGMQR4.js";
 
 // src/server.ts
 import { serve } from "@hono/node-server";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@frankieai/server",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Frankie cloud agent server — auth, sessions, MCP wiring and streaming for the embedded onboarding agent.",
   "license": "MIT",
   "type": "module",
@@ -28,7 +28,7 @@
     "yaml": "^2.9.0",
     "zod": "^4.0.0",
     "pg": "^8.13.0",
-    "@frankieai/core": "0.1.1"
+    "@frankieai/core": "0.2.0"
   },
   "devDependencies": {
     "@types/node": "^22.10.0",