@wardby/cli 0.2.0 → 0.2.1

package/dist/generated/prisma/client.d.ts

@@ -0,0 +1,247 @@
+import * as runtime from "@prisma/client/runtime/client";
+import * as $Class from "./internal/class.js";
+import * as Prisma from "./internal/prismaNamespace.js";
+export * as $Enums from './enums.js';
+export * from "./enums.js";
+/**
+ * ## Prisma Client
+ *
+ * Type-safe database client for TypeScript
+ * @example
+ * ```
+ * const prisma = new PrismaClient({
+ *   adapter: new PrismaPg({ connectionString: process.env.DATABASE_URL })
+ * })
+ * // Fetch zero or more Agents
+ * const agents = await prisma.agent.findMany()
+ * ```
+ *
+ * Read more in our [docs](https://pris.ly/d/client).
+ */
+export declare const PrismaClient: $Class.PrismaClientConstructor;
+export type PrismaClient<LogOpts extends Prisma.LogLevel = never, OmitOpts extends Prisma.PrismaClientOptions["omit"] = Prisma.PrismaClientOptions["omit"], ExtArgs extends runtime.Types.Extensions.InternalArgs = runtime.Types.Extensions.DefaultArgs> = $Class.PrismaClient<LogOpts, OmitOpts, ExtArgs>;
+export { Prisma };
+/**
+ * Model Agent
+ *
+ */
+export type Agent = Prisma.AgentModel;
+/**
+ * Model AgentSubAgent
+ * Un-phased: agent-composition edge, referenced by agent name at the
+ * import boundary (capabilities/subagents.json) but id-based here to
+ * match that Tier-1 convention. Cycle-checked in the MCP tool handler at
+ * creation time, not enforced by the database (Postgres has no native
+ * "no cycles" constraint).
+ */
+export type AgentSubAgent = Prisma.AgentSubAgentModel;
+/**
+ * Model BudgetGroup
+ * Phase 7: an optional recurring spend cap across a group of agents,
+ * layered on top of each agent's own per-run budgetUsd (which stays
+ * required and unchanged). All three period caps are independently
+ * optional -- unset means "no cap for that period." warnThresholdRatio
+ * is per-group so different groups can choose their own early-warning
+ * point; enforcement itself never lives here -- see
+ * src/core/budget-groups.ts and runner.ts's executeRun, which turn a
+ * group's remaining period budget into a tightened *effective* per-run
+ * budget the existing engine budget machinery enforces unchanged.
+ */
+export type BudgetGroup = Prisma.BudgetGroupModel;
+/**
+ * Model Tool
+ * Phase 3: a WASM-sandboxed, Zod-validated tool a model can call.
+ */
+export type Tool = Prisma.ToolModel;
+/**
+ * Model AgentTool
+ * Phase 3: explicit many-to-many join between Agent and Tool.
+ * Phase 6: per-attachment capability scoping (OWASP LLM08 fix — Excessive
+ * Agency). Empty array = no access to that resource class; a tool must be
+ * explicitly granted secrets/datastore-prefixes/hosts at attach time. A
+ * literal "*" element in allowedHosts lifts the fetch allowlist entirely
+ * (existing SSRF protection against private/link-local addresses still
+ * applies) — the back-compat escape hatch for pre-existing attachments and
+ * deliberate full-web-access tools. See src/sandbox/tool-capabilities.ts.
+ */
+export type AgentTool = Prisma.AgentToolModel;
+/**
+ * Model Datastore
+ * Named, owned resource shared across agents via AgentDatastore (Un-phased
+ * roadmap item "Named / shared datastores"). Null ownerId = public/unowned,
+ * matching Tool's convention.
+ */
+export type Datastore = Prisma.DatastoreModel;
+/**
+ * Model AgentDatastore
+ * Attaches a Datastore to an agent, addressed at sandbox point-of-use by
+ * `boundName` (sharedDatastore.get(boundName, key)) — same boundName
+ * convention as AgentSecret. Defaults to the datastore's own name.
+ */
+export type AgentDatastore = Prisma.AgentDatastoreModel;
+/**
+ * Model DatastoreEntry
+ * Phase 3: the datastore seam's Postgres-backed default. Scoped by agentId
+ * (private, per-agent) or datastoreId (shared, see Datastore above) — a row
+ * carries exactly one, enforced by a hand-written CHECK in the migration
+ * (Prisma has no declarative "exactly one of two columns" constraint).
+ * Phase 6: optional per-entry PII encryption (see `pii`/`keyId` below).
+ *
+ * `id` is a surrogate key required by Prisma's schema validator: with
+ * agentId and datastoreId both optional, neither `@@unique` below has an
+ * all-required-fields criterion, and Prisma rejects a model with no such
+ * criterion (P1012, "Each model must have at least one unique criteria
+ * that has only required fields") — `prisma generate`/`validate` refuse to
+ * run at all without it. Point lookups still go through the
+ * agentId_key/datastoreId_key compound uniques; `id` is not otherwise used.
+ */
+export type DatastoreEntry = Prisma.DatastoreEntryModel;
+/**
+ * Model AgentMemory
+ * Un-phased: agent-controlled persistent memory (key/content per agent),
+ * gated by Agent.memoryEnabled. Deliberately a separate table rather than a
+ * Datastore convention — memory has its own access surface (built-in
+ * memory_get/memory_set/memory_list/memory_search tools, not user-authored
+ * sandbox code) and its own full-text search index, which would be an odd
+ * fit bolted onto Datastore's opaque-JSON-value shape. No FK to Agent,
+ * matching DatastoreEntry: deleting an agent leaves orphaned rows today,
+ * same pre-existing gap, not a new one.
+ *
+ * `contentTsv` is maintained by application code (see
+ * PostgresAgentMemory.set), never a Postgres GENERATED column — a generated
+ * column's expression has no representation in `Unsupported()`, which risks
+ * the migration-vs-schema drift check (CLAUDE.md) never landing clean.
+ */
+export type AgentMemory = Prisma.AgentMemoryModel;
+/**
+ * Model Run
+ *
+ */
+export type Run = Prisma.RunModel;
+/**
+ * Model CodingAgentProfile
+ * Phase 5: owner-configured coding behavior. Runtime credentials and opaque
+ * launcher handles never live on the reusable profile.
+ */
+export type CodingAgentProfile = Prisma.CodingAgentProfileModel;
+/**
+ * Model CodingRun
+ * Phase 5: immutable dispatch inputs plus opaque execution/result state for
+ * one coding run. Policy is copied from the profile before work starts.
+ */
+export type CodingRun = Prisma.CodingRunModel;
+/**
+ * Model CodingProxySession
+ * Trusted-boundary state for one coding run. Only a capability digest and an
+ * upstream credential reference are persisted; neither secret value enters the DB.
+ */
+export type CodingProxySession = Prisma.CodingProxySessionModel;
+/**
+ * Model CodingProxyRequest
+ * Monotonic per-upstream-call ledger. Uncertain reservations remain held so a
+ * crash or truncated provider stream can never create new spendable budget.
+ */
+export type CodingProxyRequest = Prisma.CodingProxyRequestModel;
+/**
+ * Model SchedulerLease
+ * Phase 2: single-row-per-scope lease so exactly one scheduler process
+ * ticks at a time. `holder` is a process instance id (crypto.randomUUID()).
+ */
+export type SchedulerLease = Prisma.SchedulerLeaseModel;
+/**
+ * Model Principal
+ * Phase 4: an authenticated caller. `subject` is the IdP subject claim
+ * (delegating mode) or the configured LOCAL_PRINCIPAL (stdio, no token).
+ * Created on first sight (find-or-create by subject).
+ */
+export type Principal = Prisma.PrincipalModel;
+/**
+ * Model Task
+ *
+ */
+export type Task = Prisma.TaskModel;
+/**
+ * Model Secret
+ * Phase 4: a secret value, encrypted at rest via the SecretCipher seam.
+ * `ciphertext` is opaque to Prisma; only the cipher's decrypt() ever
+ * produces plaintext, and only at point-of-use inside the sandbox.
+ */
+export type Secret = Prisma.SecretModel;
+/**
+ * Model AgentSecret
+ * Phase 4: attaches a secret to an agent, addressed at sandbox point-of-use
+ * by `boundName` (secrets.get(boundName)). `boundName` defaults to the
+ * secret's canonical name; it differs only when the agent binds the secret
+ * under an alias, letting two agents resolve the same logical name to
+ * different underlying secrets.
+ */
+export type AgentSecret = Prisma.AgentSecretModel;
+/**
+ * Model SecretElicitationOutcome
+ * Cross-instance persistence for the out-of-band secret-entry flow
+ * (mcp/tools/secret-elicitation.ts) — was an in-process Map, which stranded
+ * a browser-form submission on the wrong instance under a multi-instance
+ * HTTP deployment. `outcome` holds the SecretElicitationOutcome JSON;
+ * `expiresAt` mirrors the old TTL sweep, now a `DELETE WHERE expiresAt <=
+ * now()` instead of a Map scan.
+ */
+export type SecretElicitationOutcome = Prisma.SecretElicitationOutcomeModel;
+/**
+ * Model Webhook
+ * Phase 4: inbound trigger for an agent. `secretHash` is an HMAC/hash of
+ * the validation secret shown to the caller once at creation; the raw
+ * secret itself is never stored.
+ */
+export type Webhook = Prisma.WebhookModel;
+/**
+ * Model OAuthClient
+ * Phase 4 (self-hosted AS only): a registered OAuth client. Created and
+ * used only under AUTH_PROVIDER=self-hosted; the delegating adapter never
+ * writes these tables even though the migration creates them unconditionally.
+ */
+export type OAuthClient = Prisma.OAuthClientModel;
+/**
+ * Model OAuthGrant
+ * Phase 4 (self-hosted AS only): an issued authorization grant / refresh token.
+ */
+export type OAuthGrant = Prisma.OAuthGrantModel;
+/**
+ * Model AuthUser
+ *
+ */
+export type AuthUser = Prisma.AuthUserModel;
+/**
+ * Model AuthLoginKey
+ *
+ */
+export type AuthLoginKey = Prisma.AuthLoginKeyModel;
+/**
+ * Model AuthSession
+ *
+ */
+export type AuthSession = Prisma.AuthSessionModel;
+/**
+ * Model AuthFormChallenge
+ *
+ */
+export type AuthFormChallenge = Prisma.AuthFormChallengeModel;
+/**
+ * Model OAuthAuthorizationRequest
+ *
+ */
+export type OAuthAuthorizationRequest = Prisma.OAuthAuthorizationRequestModel;
+/**
+ * Model OAuthAuthorizationCode
+ *
+ */
+export type OAuthAuthorizationCode = Prisma.OAuthAuthorizationCodeModel;
+/**
+ * Model OAuthFamily
+ *
+ */
+export type OAuthFamily = Prisma.OAuthFamilyModel;
+/**
+ * Model AuthRateLimit
+ *
+ */
+export type AuthRateLimit = Prisma.AuthRateLimitModel;

package/dist/generated/prisma/client.js

@@ -0,0 +1,34 @@
+/* !!! This is code generated by Prisma. Do not edit directly. !!! */
+/* eslint-disable */
+// biome-ignore-all lint: generated file
+// @ts-nocheck 
+/*
+ * This file should be your main import to use Prisma. Through it you get access to all the models, enums, and input types.
+ * If you're looking for something you can import in the client-side of your application, please refer to the `browser.ts` file instead.
+ *
+ * 🟢 You can import this file directly.
+ */
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+globalThis['__dirname'] = path.dirname(fileURLToPath(import.meta.url));
+import * as $Class from "./internal/class.js";
+import * as Prisma from "./internal/prismaNamespace.js";
+export * as $Enums from './enums.js';
+export * from "./enums.js";
+/**
+ * ## Prisma Client
+ *
+ * Type-safe database client for TypeScript
+ * @example
+ * ```
+ * const prisma = new PrismaClient({
+ *   adapter: new PrismaPg({ connectionString: process.env.DATABASE_URL })
+ * })
+ * // Fetch zero or more Agents
+ * const agents = await prisma.agent.findMany()
+ * ```
+ *
+ * Read more in our [docs](https://pris.ly/d/client).
+ */
+export const PrismaClient = $Class.getPrismaClientClass();
+export { Prisma };