@usecontextlayer/cli 0.15.0 → 0.16.0

package/dist/template/AGENTS.md

@@ -1,13 +1,13 @@
-# ContextLayer app
+# ContextLayer slate
 
-The interactive app declares resources in public/slate.json. Each agent declares its resources in agents/<name>/slate.json. All declarations share one namespace: matching database slugs select the same database, and repeated declarations must agree on owner/viewer mode. Connections and secrets follow the same namespace rule.
+Follow ContextLayer's [domain model and resource invariants](https://github.com/usecontextlayer/contextlayer/blob/main/ARCHITECTURE.md#domain-model). Put the app's declaration in `public/slate.json`, agent declarations in `agents/<name>/slate.json`, and MCP declarations in `mcp/<name>/slate.json`. Declare each resource in every consumer that needs it. All declarations share one namespace: matching database slugs select the same database, and repeated declarations must agree on owner/viewer mode. Connections and secrets follow the same namespace rule. MCP declaration resource collections must currently be empty because MCP resource execution is not implemented.
 
 ## Databases and migrations
 
-Persistent app data belongs in declared SQLite databases. Each database keeps its Drizzle configuration, query schema and migration history under databases/<name>. The updates directory is an example; declare it in the relevant Slates to use it, or create the corresponding directory for your own database.
+Keep persistent slate data in declared SQLite databases and treat agent filesystem files as scratch data. Keep each database's Drizzle configuration, query schema, and migration history under `databases/<slug>`. The `updates` directory is an example; declare it where needed or create the corresponding directory for another database.
 
-Write SQL migrations explicitly. Run pnpm db:migration --config databases/<name>/drizzle.config.ts --name <change> to scaffold a blank migration with Drizzle Kit's native metadata, then author its SQL. Separate statements with Drizzle's --> statement-breakpoint marker. Commit the SQL and generated metadata. Never generate migrations from schema changes, run drizzle-kit push, or change deployed schemas ad hoc. Update schema.ts for typed queries alongside the SQL; the schema does not create tables.
+Write SQL migrations explicitly, following the [README workflow](README.md#store-slate-data). Separate statements with Drizzle's `--> statement-breakpoint` marker. Commit the SQL and generated metadata together. Never generate migrations from schema changes, run `drizzle-kit push`, or change deployed schemas ad hoc. Update `schema.ts` for typed queries alongside the SQL; the schema does not create tables.
 
-Platform applies pending migrations when publishing the app and when a member joins. Local Vite startup applies current-checkout migrations to ignored .contextlayer/databases before the app runs. Local agents use that same native local storage. Owner/viewer modes select hosted ownership; both use developer-local storage during development. No database selector or assignment is needed.
+Preserve platform's [database ownership and provisioning boundary](https://github.com/usecontextlayer/contextlayer/blob/main/ARCHITECTURE.md#slate-databases-and-authored-migrations). Authored code names declared slugs; leave physical instances and credentials to ContextLayer.
 
-Loaders and actions receive the request-scoped databasesContext from @usecontextlayer/sdk. Use database(context.get(databasesContext), "updates", schema) for native Drizzle queries, or call the capability's query(slug, sql, params) for SQL. Import the query schema through the app’s @/databases alias. Authored code selects declared slugs; platform owns physical instances and credentials. Agent database_query writes persist immediately. Sandbox files are scratch data.
+Use `databasesContext` from `@usecontextlayer/sdk` in loaders and actions, and `database_query` in agents. Import the query schema through the checkout's `@/databases` alias. The [SDK guide](https://www.npmjs.com/package/@usecontextlayer/sdk) documents the Drizzle and direct SQL APIs.

package/dist/template/README.md

@@ -1,37 +1,39 @@
-# Your ContextLayer app
+# Your ContextLayer slate
 
-This React Router app uses ContextLayer for connected services and is published through its Git remote.
+This slate contains an interactive React Router app, uses ContextLayer for connected services, and is deployed through its Git remote.
+
+See ContextLayer's [domain model](https://github.com/usecontextlayer/contextlayer/blob/main/ARCHITECTURE.md#domain-model) for declarations, resources, Owners, and assignments.
 
 ## Develop locally
 
-From this directory, run:
+From the checkout root, run:
 
 ```sh
 pnpm dev
 ```
 
-Open the local URL printed by the development server. Edit `app/routes/home.tsx` to build your first page. Use `pnpm typecheck` and `pnpm build` for the app's normal TypeScript and production-build commands.
+Open the local URL printed by the development server. Edit `app/routes/home.tsx` to build your first page. Use `pnpm typecheck` and `pnpm build` for the checkout's normal TypeScript and production-build commands.
 
 ## Use connected services
 
-Declare the services your app needs in `public/slate.json`. Authorization connects your account to ContextLayer; assignment binds that account to one of your app's declared connection slugs. Approve authorization in your browser, then use the local assignment chooser to select the account. An already connected account can go directly to assignment. Command help supplies the supported operations:
+Declare the connections your app needs in `public/slate.json`. Connect an account to ContextLayer in your browser, then assign the connected account to one of your app's declared connections. An already connected account can go directly to assignment. Command help supplies the supported operations:
 
 ```sh
 npx @usecontextlayer/cli connections --help
 npx @usecontextlayer/cli connection --help
 ```
 
-The installed SDK guide at `node_modules/@usecontextlayer/sdk/README.md` gives the complete Gmail sequence: copy its route and declaration, authorize Gmail when needed, assign `work-email`, and start development. Local account choices are saved in ignored `.contextlayer/connections.json`. Restart `pnpm dev` after changing declarations or local assignments.
+The installed SDK guide at `node_modules/@usecontextlayer/sdk/README.md` gives the complete Gmail sequence: copy its route and declaration, connect a Gmail account when needed, assign it to `work-email`, and start development. Local assignments are saved in ignored `.contextlayer/connections.json`. Restart `pnpm dev` after changing declarations or local assignments.
 
-## Store app data
+## Store slate data
 
-Declare database slugs in `public/slate.json` or `agents/<name>/slate.json`. Matching declarations within this app share data; each declaration selects hosted `owner` or `viewer` mode. Local development persists SQLite state in ignored `.contextlayer/databases`.
+Declare database slugs in `public/slate.json` or `agents/<name>/slate.json`, following the [resource invariants](https://github.com/usecontextlayer/contextlayer/blob/main/ARCHITECTURE.md#resource-configuration-and-execution--principles). Local development persists SQLite state in ignored `.contextlayer/databases`.
 
-Keep each database’s Drizzle configuration, query schema and migrations under `databases/<name>`. Run `pnpm db:migration --config databases/<name>/drizzle.config.ts --name <change>`, then write the blank SQL migration explicitly and update the query schema. Commit the SQL and native journal together. The query schema supplies types and does not generate the deployed database schema. The installed SDK guide documents `databasesContext` and the native Drizzle query client.
+Keep each database’s Drizzle configuration, query schema and migrations under `databases/<slug>`. Run `pnpm db:migration --config databases/<slug>/drizzle.config.ts --name <change>`, then write the blank SQL migration explicitly and update the query schema. Commit the SQL and native journal together. The query schema supplies types and does not generate the deployed database schema. The installed SDK guide documents `databasesContext` and the native Drizzle query client.
 
-Local startup applies the checkout’s migrations before queries. Hosted publication applies pending committed migrations for existing members, and joining applies the full history for a new member. Viewer-mode hosted execution requires joining; account configuration is available before joining. Agent filesystem files are scratch; use `database_query` for persistent data.
+Restart local development after adding a migration. Push committed migrations to `main` for hosted provisioning; see [database ownership and provisioning](https://github.com/usecontextlayer/contextlayer/blob/main/ARCHITECTURE.md#slate-databases-and-authored-migrations) for its lifecycle. Use `database_query` for persistent agent data.
 
-## Publish
+## Deploy
 
 Commit your changes and push the generated `main` branch:
 
@@ -41,4 +43,4 @@ git commit
 git push -u origin main
 ```
 
-ContextLayer builds and deploys the app through its native Git remote. Your dashboard and hosted URL were printed by initialization. The hosted URL becomes usable after deployment succeeds. The app starts private; sign in with your ContextLayer account to open it. Hosted account selection uses the app's ContextLayer header.
+ContextLayer builds and deploys the slate through its native Git remote. Your dashboard and hosted URL were printed by initialization. The hosted URL becomes usable after deployment succeeds. The slate starts private; sign in with your ContextLayer account to open it. Configure hosted assignments in the header of the [chrome](https://github.com/usecontextlayer/contextlayer/blob/main/ARCHITECTURE.md#slate-chrome).

package/dist/template/app/root.tsx

@@ -11,25 +11,25 @@ export default function App() {
 
 export function ErrorBoundary({ error }: Route.ErrorBoundaryProps) {
 	if (isRouteErrorResponse(error) && error.status === 409) {
-		const setup = connectionRequiredSchema.safeParse(error.data)
-		if (setup.success) {
+		const unassignedConnection = connectionRequiredSchema.safeParse(error.data)
+		if (unassignedConnection.success) {
 			return (
 				<main className="container mx-auto p-4 pt-16">
-					<h1 className="text-2xl font-semibold">Connect an account to continue</h1>
+					<h1 className="text-2xl font-semibold">Assign an account to continue</h1>
 					{import.meta.env.DEV ? (
 						<>
 							<p className="mt-3">
-								From your app directory, assign an account, then restart{" "}
+								From the checkout root, assign a connected account, then restart{" "}
 								<code>pnpm dev</code>:
 							</p>
 							<pre className="mt-4 overflow-x-auto">
-								<code>{`npx @usecontextlayer/cli connection local assign ${setup.data.slug}`}</code>
+								<code>{`npx @usecontextlayer/cli connection local assign ${unassignedConnection.data.slug}`}</code>
 							</pre>
 						</>
 					) : (
 						<p className="mt-3">
-							Open the connections menu above and choose an account, then refresh this
-							page.
+							Open the connections menu in the ContextLayer header above and assign a
+							connected account, then refresh this page.
 						</p>
 					)}
 				</main>

package/dist/template/app/routes/home.tsx

@@ -1,22 +1,23 @@
 export function meta() {
-	return [{ title: "Your ContextLayer app" }]
+	return [{ title: "Your ContextLayer slate" }]
 }
 
 export default function Home() {
 	return (
 		<main className="mx-auto max-w-2xl space-y-6 px-4 py-16">
-			<h1 className="text-2xl font-semibold">Your ContextLayer app is ready</h1>
+			<h1 className="text-2xl font-semibold">Your ContextLayer slate is ready</h1>
 			<p>
 				Edit <code>app/routes/home.tsx</code> to build your first page.
 			</p>
 			<p>
-				To read from a connected service, declare it in <code>public/slate.json</code>,
-				assign your account through the CLI, and call its tools from a route loader.
-				Follow the Gmail example in the SDK guide to get started.
+				To read from a connected service, declare a connection in{" "}
+				<code>public/slate.json</code>, assign a connected account through the CLI, and
+				call its tools from a route loader. Follow the Gmail example in the SDK guide to
+				get started.
 			</p>
 			<p>
-				Your project&apos;s <code>README.md</code> explains development, connections, and
-				publishing. The SDK guide is in{" "}
+				Your checkout&apos;s <code>README.md</code> explains development, connections, and
+				deployment. The SDK guide is in{" "}
 				<code>node_modules/@usecontextlayer/sdk/README.md</code>.
 			</p>
 		</main>

package/dist/template/workers/app.ts

@@ -1,6 +1,6 @@
-import { createApp, type McpToolModule } from "@usecontextlayer/sdk/worker"
+import { createSlateWorker, type McpToolModule } from "@usecontextlayer/sdk/worker"
 
-export default createApp({
+export default createSlateWorker({
 	build: () => import("virtual:react-router/server-build"),
 	development: import.meta.env.DEV,
 	mcp: import.meta.glob<McpToolModule>("/mcp/*/index.ts", { eager: true }),

package/dist/template/workers/local-resources/index.ts

@@ -1 +1,6 @@
-export { AppDatabase, DatabaseSetup, Databases, Tools } from "@usecontextlayer/sdk/local"
+export {
+	DatabaseProvisioning,
+	Databases,
+	SlateDatabase,
+	Tools,
+} from "@usecontextlayer/sdk/local"

package/dist/template/workers/local-resources/wrangler.jsonc

@@ -3,7 +3,7 @@
 	"durable_objects": {
 		"bindings": [
 			{
-				"class_name": "AppDatabase",
+				"class_name": "SlateDatabase",
 				"name": "DATABASE_STORAGE"
 			}
 		]
@@ -11,7 +11,7 @@
 	"main": "index.ts",
 	"migrations": [
 		{
-			"new_sqlite_classes": ["AppDatabase"],
+			"new_sqlite_classes": ["SlateDatabase"],
 			"tag": "v1"
 		}
 	],

package/dist/vite.d.mts

@@ -4273,7 +4273,22 @@ declare namespace external_d_exports {
   export { $brand, $input, $output, BRAND, CompileOptions, GlobalMeta, INVALID, Infer, IssueData, JSONType, NEVER, $RefinementCtx as RefinementCtx, SafeExtendShape, Schema, TimePrecision, TypeOf, ZodAny, ZodArray, ZodBase64, ZodBase64URL, ZodBigInt, ZodBigIntFormat, ZodBoolean, ZodCIDRv4, ZodCIDRv6, ZodCUID, ZodCUID2, ZodCatch, ZodCodec, ZodCoercedBigInt, ZodCoercedBoolean, ZodCoercedDate, ZodCoercedNumber, ZodCoercedString, ZodCompileAsyncError, ZodCompileUnsupportedError, ZodCreditCard, ZodCustom, ZodCustomStringFormat, ZodDate, ZodDefault, ZodDiscriminatedUnion, ZodE164, ZodEmail, ZodEmoji, ZodEnum, ZodError, ZodErrorMap, ZodExactOptional, ZodFile, ZodFirstPartySchemaTypes, ZodFirstPartyTypeKind, ZodFlattenedError, ZodFloat32, ZodFloat64, ZodFormattedError, ZodFunction, ZodGUID, ZodIBAN, ZodIPv4, ZodIPv6, ZodISODate, ZodISODateTime, ZodISODuration, ZodISOTime, ZodInstanceOf, ZodInt, ZodInt32, ZodInt64, ZodIntersection, ZodIssue, ZodIssueCode, ZodJSONSchema, ZodJSONSchemaInternals, ZodJWT, ZodKSUID, ZodLazy, ZodLiteral, ZodMAC, ZodMap, ZodNaN, ZodNanoID, ZodNever, ZodNonOptional, ZodNull, ZodNullable, ZodNumber, ZodNumberFormat, ZodObject, ZodOptional, ZodPipe, ZodPrefault, ZodPreprocess, ZodPromise, ZodRawShape, ZodReadonly, ZodRealError, ZodRecord, ZodSafeParseError, ZodSafeParseResult, ZodSafeParseSuccess, ZodSchema, ZodSet, ZodStandardSchemaWithJSON, ZodString, ZodStringFormat, ZodSuccess, ZodSymbol, ZodTemplateLiteral, ZodTransform, ZodTuple, ZodType, ZodTypeAny, ZodUInt32, ZodUInt64, ZodULID, ZodURL, ZodUUID, ZodUndefined, ZodUnion, ZodUnknown, ZodVoid, ZodXID, ZodXor, _ZodBigInt, _ZodBoolean, _ZodDate, _ZodNumber, _ZodString, _ZodType, _default, _function, any, array, base64, base64url, bigint$1 as bigint, boolean$1 as boolean, _catch as catch, check, cidrv4, cidrv6, clone, codec, coerce_d_exports as coerce, compile, config, index_d_exports as core, creditCard, cuid, cuid2, currencyCode, custom, date$2 as date, decode, decodeAsync, deepPartial, describe, discriminatedUnion, e164, email, emoji, encode, encodeAsync, _endsWith as endsWith, _enum as enum, exactOptional, file, flattenError, float32, float64, formatError, fromJSONSchema, _function as function, getDiscriminatedOption, getErrorMap, globalRegistry, _gt as gt, _gte as gte, guid, hash, hex, hostname, httpUrl, iban, _includes as includes, output$1 as infer, inferFlattenedErrors, inferFormattedError, input, _instanceof as instanceof, int, int32, int64, intersection, invertCodec, ipv4, ipv6, iso_d_exports as iso, json, jwt, keyof, ksuid, lazy, _length as length, literal, index_d_exports$1 as locales, looseObject, looseRecord, _lowercase as lowercase, _lt as lt, _lte as lte, mac, map, _maxLength as maxLength, _maxSize as maxSize, memoizer, meta, _mime as mime, _minLength as minLength, _minSize as minSize, _multipleOf as multipleOf, nan, nanoid, nativeEnum, _negative as negative, never, _nonnegative as nonnegative, nonoptional, _nonpositive as nonpositive, _normalize as normalize, _null as null, nullable, nullish, number$1 as number, object, optional, output, _overwrite as overwrite, parse, parseAsync, partialRecord, pipe, _positive as positive, prefault, preprocess, prettifyError, promise, _properties as properties, _property as property, readonly, record, refine, _regex as regex, regexes_d_exports as regexes, registry, safeDecode, safeDecodeAsync, safeEncode, safeEncodeAsync, safeParse, safeParseAsync, set, setErrorMap, _size as size, _slugify as slugify, _startsWith as startsWith, strictObject, string$1 as string, stringFormat, stringbool, success, superRefine, symbol, templateLiteral, toJSONSchema, _toLowerCase as toLowerCase, _toUpperCase as toUpperCase, toZod, transform, treeifyError, _trim as trim, tuple, uint32, uint64, ulid, _undefined as undefined, union, unknown, _uppercase as uppercase, url, util_d_exports as util, uuid, uuidv4, uuidv6, uuidv7, validate, validateAsync, _void as void, withParser, xid, xor };
 }
 //#endregion
-//#region ../shared/dist/app-resources-CJH87mYB.d.mts
+//#region ../shared/dist/databases.d.mts
+declare const sqlValueSchema: ZodUnion<readonly [ZodString, ZodNumber, ZodNull]>;
+type SqlValue = output$1<typeof sqlValueSchema>;
+declare const databaseResultSchema: ZodObject<{
+  columns: ZodArray<ZodString>;
+  rows: ZodArray<ZodArray<ZodUnion<readonly [ZodString, ZodNumber, ZodNull]>>>;
+  rowsRead: ZodNumber;
+  rowsWritten: ZodNumber;
+}, $strip>;
+type DatabaseResult = output$1<typeof databaseResultSchema>;
+interface Databases {
+  query(slug: string, sql: string, params?: SqlValue[]): Promise<DatabaseResult>;
+}
+//#endregion
+//#endregion
+//#region ../shared/dist/slate-resources-zjMlTUWg.d.mts
 declare const localResourceConfigurationSchema: ZodObject<{
   connections: ZodRecord<ZodString, ZodObject<{
     mode: ZodEnum<{
@@ -4329,23 +4344,8 @@ declare const localResourceConfigurationSchema: ZodObject<{
 }, $strict>;
 type LocalResourceConfiguration = output$1<typeof localResourceConfigurationSchema>;
 //#endregion
-//#region ../shared/dist/databases.d.mts
-declare const sqlValueSchema: ZodUnion<readonly [ZodString, ZodNumber, ZodNull]>;
-type SqlValue = output$1<typeof sqlValueSchema>;
-declare const databaseResultSchema: ZodObject<{
-  columns: ZodArray<ZodString>;
-  rows: ZodArray<ZodArray<ZodUnion<readonly [ZodString, ZodNumber, ZodNull]>>>;
-  rowsRead: ZodNumber;
-  rowsWritten: ZodNumber;
-}, $strip>;
-type DatabaseResult = output$1<typeof databaseResultSchema>;
-interface Databases {
-  query(slug: string, sql: string, params?: SqlValue[]): Promise<DatabaseResult>;
-}
-//#endregion
-//#endregion
 //#region vite.d.ts
-export declare function localDatabaseSetup(bindings: Awaited<ReturnType<typeof getLocalResourcesBindings>>): Plugin;
+export declare function localDatabaseProvisioning(bindings: Awaited<ReturnType<typeof getLocalResourcesBindings>>): Plugin;
 export declare function getPreparedLocalBindings(server: ViteDevServer): Awaited<ReturnType<typeof getLocalResourcesBindings>>;
 export declare function getLocalResourcesBindings(): Promise<{
   configuration: {
@@ -4418,7 +4418,6 @@ export declare function getLocalResourcesBindings(): Promise<{
     };
   };
   props: {
-    appId: string;
     connections: {
       [k: string]: {
         mode: "owner" | "viewer";
@@ -4436,6 +4435,7 @@ export declare function getLocalResourcesBindings(): Promise<{
       token: string;
       type: "access-token";
     };
+    slateId: string;
   } | undefined;
   proxyConfigPath: string;
   vars: {
@@ -4447,6 +4447,6 @@ export declare function openLocalDatabases(workerName: string, databases: LocalR
   databases: Databases;
   dispose: PlatformProxy["dispose"];
 }>;
-export declare function setupLocalDatabases(bindings: Awaited<ReturnType<typeof getLocalResourcesBindings>>): Promise<void>;
+export declare function provisionLocalDatabases(bindings: Awaited<ReturnType<typeof getLocalResourcesBindings>>): Promise<void>;
 //#endregion
 //# sourceMappingURL=vite.d.mts.map