@agentic-kit/pi 0.17.1 → 0.18.0

package/esm/tools/templates.js

@@ -1,337 +0,0 @@
-import { filterInternalPolicies } from '@agentic-kit/harness';
-import { z } from 'zod';
-import { resolveProjectContext } from '../context';
-import { toolSchema } from '../tool-schema';
-// A stored blueprint field's `type` is an expanded object (`{ name: 'text' }`),
-// not the bare string the agent passes to provision_blueprint. Flatten it to the
-// type name so the renderer gets a string, never an object (which React can't
-// render as a child).
-function fieldTypeName(raw) {
-    if (typeof raw === 'string')
-        return raw;
-    if (raw && typeof raw === 'object' && typeof raw.name === 'string') {
-        return raw.name;
-    }
-    return '';
-}
-// A template's definition is a stored blueprint (see BlueprintDefinitionSchema):
-// { tables: [{ table_name, fields, policies }], relations: [{ source_table, … }] }.
-// Parse it into the same table shape provision_blueprint surfaces so the renderer
-// can reuse TableCard. Defensive throughout — it's untyped JSON from the catalog.
-function parseTemplateTables(definition) {
-    if (!definition || typeof definition !== 'object')
-        return [];
-    const def = definition;
-    const tables = Array.isArray(def.tables) ? def.tables : [];
-    const relations = Array.isArray(def.relations) ? def.relations : [];
-    return tables.map((raw) => {
-        const table = raw;
-        const fields = Array.isArray(table.fields) ? table.fields : [];
-        const policies = Array.isArray(table.policies) ? table.policies : [];
-        return {
-            name: table.table_name ?? '',
-            fields: fields.map((rawField) => {
-                const field = rawField;
-                return {
-                    name: field.name ?? '',
-                    type: fieldTypeName(field.type),
-                    isRequired: field.is_required ?? false,
-                    defaultValue: typeof field.default === 'string' ? field.default : null,
-                };
-            }),
-            policies: filterInternalPolicies(policies.map((policy) => policy.$type ?? '').filter(Boolean)),
-            relationCount: relations.filter((relation) => relation.source_table === table.table_name).length,
-        };
-    });
-}
-function formatTemplatesText(templates) {
-    if (templates.length === 0)
-        return 'No blueprint templates available.';
-    const lines = [`Available blueprint templates (${templates.length}):`];
-    for (const template of templates) {
-        const cats = template.categories.length ? ` [${template.categories.join(', ')}]` : '';
-        lines.push(`  ${template.displayName} — ${template.tables.length} tables${cats}`);
-        for (const table of template.tables) {
-            lines.push(`    - ${table.name} (${table.fields.length} field${table.fields.length === 1 ? '' : 's'})`);
-        }
-    }
-    return lines.join('\n');
-}
-// The latest project blueprint (or a named one) — the definition source for
-// create_template, and for the confirm preview of the tables it will template.
-// A blueprintName is a best-effort hint: if it matches nothing (the agent often
-// guesses casing/wording), fall back to the most recent blueprint so the confirm
-// still previews real tables and execute templates the same one it previewed.
-async function fetchLatestBlueprint(context, blueprintName) {
-    const found = await context.modules.blueprint
-        .findMany({
-        select: { displayName: true, definition: true },
-        where: {
-            databaseId: { equalTo: context.databaseId },
-            ...(blueprintName ? { displayName: { equalTo: blueprintName } } : {}),
-        },
-        orderBy: ['CREATED_AT_DESC'],
-        first: 1,
-    })
-        .unwrap();
-    return found.blueprints?.nodes?.[0];
-}
-async function findProjectBlueprint(context, blueprintName) {
-    let node = await fetchLatestBlueprint(context, blueprintName);
-    if (!node && blueprintName)
-        node = await fetchLatestBlueprint(context, undefined);
-    return node?.definition ? { displayName: node.displayName ?? '', definition: node.definition } : null;
-}
-// The create_template confirm preview — the source blueprint's name and its
-// tables, parsed into the shape the renderer's TableCard reuses. Best-effort: any
-// failure yields no tables rather than blocking the confirm.
-export async function createTemplatePreviewTables(context, blueprintName) {
-    try {
-        const blueprint = await findProjectBlueprint(context, blueprintName);
-        if (!blueprint)
-            return { blueprintName: '', tables: [] };
-        return {
-            blueprintName: blueprint.displayName,
-            tables: parseTemplateTables(blueprint.definition),
-        };
-    }
-    catch (err) {
-        console.warn('[db-tools] create_template preview lookup failed:', err);
-        return { blueprintName: '', tables: [] };
-    }
-}
-async function resolveTemplateId(client, displayName) {
-    const result = await client.blueprintTemplate
-        .findMany({
-        select: { id: true, displayName: true },
-        where: { displayName: { equalTo: displayName } },
-        first: 1,
-    })
-        .unwrap();
-    const template = result.blueprintTemplates?.nodes?.[0];
-    if (!template?.id)
-        throw new Error(`Template "${displayName}" not found`);
-    return template.id;
-}
-function done(success, message) {
-    return { content: [{ type: 'text', text: message }], details: { success, message } };
-}
-// ── list_templates ────────────────────────────────────────────────────────
-const ListTemplatesZod = z.object({});
-const ListTemplatesSchema = toolSchema(ListTemplatesZod);
-export const listTemplatesTool = {
-    name: 'list_templates',
-    label: 'List templates',
-    description: 'List the blueprint templates available to provision into the project database (display name, description, categories, table count). Read-only — these are a global catalog, not the project schema.',
-    promptSnippet: 'list_templates: list the available blueprint templates to apply. Read-only — call before apply_template.',
-    parameters: ListTemplatesSchema,
-    async execute(_id, _params, _signal, _onUpdate, ctx) {
-        const resolved = await resolveProjectContext(ctx.cwd);
-        if (!resolved.context) {
-            return { content: [{ type: 'text', text: resolved.reason }], details: { templates: [] } };
-        }
-        const result = await resolved.context.modules.blueprintTemplate
-            .findMany({
-            select: {
-                displayName: true,
-                description: true,
-                categories: true,
-                definition: true,
-            },
-            orderBy: ['NAME_ASC'],
-        })
-            .execute();
-        if (!result.ok) {
-            const message = result.errors.map((e) => e.message).join('; ');
-            return {
-                content: [{ type: 'text', text: `Failed to read templates: ${message}` }],
-                details: { templates: [] },
-            };
-        }
-        const templates = (result.data.blueprintTemplates?.nodes ?? []).map((template) => ({
-            displayName: template.displayName ?? '',
-            description: template.description ?? null,
-            categories: Array.isArray(template.categories) ? template.categories : [],
-            tables: parseTemplateTables(template.definition),
-        }));
-        return {
-            content: [{ type: 'text', text: formatTemplatesText(templates) }],
-            details: { templates },
-        };
-    },
-};
-// ── create_template ───────────────────────────────────────────────────────
-const CreateTemplateZod = z.object({
-    displayName: z.string().describe('Display name for the new blueprint template'),
-    blueprintName: z
-        .string()
-        .describe('Display name of an existing project blueprint to save as the template. Defaults to the most recently provisioned blueprint.')
-        .optional(),
-    description: z.string().describe('Description shown in the template catalog').optional(),
-    categories: z
-        .array(z.string())
-        .describe('Categories for catalog grouping and discovery')
-        .optional(),
-});
-const CreateTemplateSchema = toolSchema(CreateTemplateZod);
-export const createTemplateTool = {
-    name: 'create_template',
-    label: 'Create template',
-    description: 'Save an existing project blueprint into the global template catalog as a reusable blueprint template. Defaults to the most recently provisioned blueprint; pass blueprintName to pick a specific one by display name. Gated.',
-    promptSnippet: 'create_template: save a project blueprint to the reusable template catalog. Gated.',
-    parameters: CreateTemplateSchema,
-    async execute(_id, params, _signal, _onUpdate, ctx) {
-        const resolved = await resolveProjectContext(ctx.cwd);
-        if (!resolved.context)
-            return done(false, resolved.reason);
-        const { modules, ownerId } = resolved.context;
-        if (!ownerId)
-            return done(false, 'Not authenticated (missing OWNER_ID in .env).');
-        try {
-            const blueprint = await findProjectBlueprint(resolved.context, params.blueprintName);
-            if (!blueprint) {
-                const which = params.blueprintName ? `"${params.blueprintName}"` : 'any blueprint';
-                return done(false, `No project blueprint found (${which}). Provision a blueprint first.`);
-            }
-            const base = params.displayName.toLowerCase().replace(/\s+/g, '_');
-            await modules.blueprintTemplate
-                .create({
-                data: {
-                    ownerId,
-                    name: `${base}_${Date.now()}`,
-                    displayName: params.displayName,
-                    description: params.description,
-                    categories: params.categories,
-                    definition: blueprint.definition,
-                },
-                select: { id: true, displayName: true },
-            })
-                .unwrap();
-            const message = `Created template "${params.displayName}"`;
-            return {
-                content: [{ type: 'text', text: message }],
-                details: {
-                    success: true,
-                    message,
-                    displayName: params.displayName,
-                    blueprintName: blueprint.displayName,
-                    tables: parseTemplateTables(blueprint.definition),
-                },
-            };
-        }
-        catch (err) {
-            return done(false, err instanceof Error ? err.message : 'Failed to create template');
-        }
-    },
-};
-// ── apply_template ────────────────────────────────────────────────────────
-const ApplyTemplateZod = z.object({
-    templateName: z.string().describe('The display name of the blueprint template to apply'),
-    nameOverride: z
-        .string()
-        .describe('Optional name override for the created blueprint (snake_case). Defaults to template name.')
-        .optional(),
-});
-const ApplyTemplateSchema = toolSchema(ApplyTemplateZod);
-export const applyTemplateTool = {
-    name: 'apply_template',
-    label: 'Apply template',
-    description: 'Apply an existing blueprint template to the project database, creating its tables. Use the template display name (from list_templates).',
-    promptSnippet: 'apply_template: provision a saved blueprint template by display name. Gated.',
-    parameters: ApplyTemplateSchema,
-    async execute(_id, params, _signal, _onUpdate, ctx) {
-        const resolved = await resolveProjectContext(ctx.cwd);
-        if (!resolved.context)
-            return done(false, resolved.reason);
-        const { modules, databaseId, schemaId, ownerId } = resolved.context;
-        if (!ownerId)
-            return done(false, 'Not authenticated (missing OWNER_ID in .env).');
-        try {
-            const templateId = await resolveTemplateId(modules, params.templateName);
-            const base = params.nameOverride ?? params.templateName.toLowerCase().replace(/\s+/g, '_');
-            const nameOverride = `${base}_${Date.now()}`;
-            const copyResult = await modules.mutation
-                .copyTemplateToBlueprint({ input: { templateId, databaseId, ownerId, nameOverride } }, { select: { result: true } })
-                .unwrap();
-            const blueprintId = copyResult.copyTemplateToBlueprint?.result;
-            if (!blueprintId)
-                throw new Error('Failed to copy template');
-            const constructResult = await modules.mutation
-                .constructBlueprint({ input: { blueprintId, schemaId } }, { select: { result: true } })
-                .unwrap();
-            const refMap = constructResult.constructBlueprint?.result;
-            if (!refMap)
-                return done(false, `Construction failed for template "${params.templateName}"`);
-            const createdCount = Object.keys(refMap).length;
-            return done(true, `Applied template "${params.templateName}" — created ${createdCount} table${createdCount === 1 ? '' : 's'}`);
-        }
-        catch (err) {
-            return done(false, err instanceof Error ? err.message : 'Failed to apply template');
-        }
-    },
-};
-// ── update_template ───────────────────────────────────────────────────────
-const UpdateTemplateZod = z.object({
-    templateName: z.string().describe('The display name of the blueprint template to update'),
-    patch: z.object({
-        displayName: z.string().describe('New display name').optional(),
-        description: z.string().describe('New description').optional(),
-        categories: z.array(z.string()).describe('New categories').optional(),
-        tags: z.array(z.string()).describe('New tags').optional(),
-        visibility: z.enum(['private', 'public']).describe('New visibility').optional(),
-    }),
-});
-const UpdateTemplateSchema = toolSchema(UpdateTemplateZod);
-export const updateTemplateTool = {
-    name: 'update_template',
-    label: 'Update template',
-    description: 'Update a blueprint template’s metadata (display name, description, categories, tags, visibility).',
-    promptSnippet: 'update_template: edit a saved template’s metadata by display name. Gated.',
-    parameters: UpdateTemplateSchema,
-    async execute(_id, params, _signal, _onUpdate, ctx) {
-        const resolved = await resolveProjectContext(ctx.cwd);
-        if (!resolved.context)
-            return done(false, resolved.reason);
-        try {
-            const templateId = await resolveTemplateId(resolved.context.modules, params.templateName);
-            await resolved.context.modules.blueprintTemplate
-                .update({
-                where: { id: templateId },
-                data: params.patch,
-                select: { id: true, displayName: true },
-            })
-                .unwrap();
-            return done(true, `Updated template "${params.templateName}"`);
-        }
-        catch (err) {
-            return done(false, err instanceof Error ? err.message : 'Failed to update template');
-        }
-    },
-};
-// ── delete_template ───────────────────────────────────────────────────────
-const DeleteTemplateZod = z.object({
-    templateName: z.string().describe('The display name of the blueprint template to delete'),
-});
-const DeleteTemplateSchema = toolSchema(DeleteTemplateZod);
-export const deleteTemplateTool = {
-    name: 'delete_template',
-    label: 'Delete template',
-    description: 'Permanently delete a blueprint template by its display name.',
-    promptSnippet: 'delete_template: remove a saved template by display name. Destructive — gated.',
-    parameters: DeleteTemplateSchema,
-    async execute(_id, params, _signal, _onUpdate, ctx) {
-        const resolved = await resolveProjectContext(ctx.cwd);
-        if (!resolved.context)
-            return done(false, resolved.reason);
-        try {
-            const templateId = await resolveTemplateId(resolved.context.modules, params.templateName);
-            await resolved.context.modules.blueprintTemplate
-                .delete({ where: { id: templateId }, select: { id: true } })
-                .unwrap();
-            return done(true, `Deleted template "${params.templateName}"`);
-        }
-        catch (err) {
-            return done(false, err instanceof Error ? err.message : 'Failed to delete template');
-        }
-    },
-};

package/policy/add-policies-to-table.d.ts

@@ -1,26 +0,0 @@
-import { type PolicyProvisioningCategory } from '@agentic-kit/harness';
-import type { ModulesClient } from '../context';
-import { type CrudOperation, type CrudPolicyConfigs } from './provision-helpers';
-export interface AddPoliciesToTablePolicyEntry {
-    policyType: string;
-    dataNodeType?: string;
-    nodeData?: Record<string, unknown>;
-    sharedPolicyData: Record<string, unknown>;
-    operations: CrudPolicyConfigs;
-    enabledOperations?: CrudOperation[];
-}
-export interface AddPoliciesToTableInput {
-    client: ModulesClient;
-    databaseId: string;
-    schemaId: string;
-    tableId: string;
-    policies: AddPoliciesToTablePolicyEntry[];
-}
-export declare class UnsupportedPolicyCategoryError extends Error {
-    readonly policyType: string;
-    readonly category: PolicyProvisioningCategory;
-    constructor(policyType: string, category: PolicyProvisioningCategory);
-}
-export declare function addPoliciesToExistingTable(input: AddPoliciesToTableInput): Promise<{
-    success: true;
-}>;

package/policy/add-policies-to-table.js

@@ -1,71 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnsupportedPolicyCategoryError = void 0;
-exports.addPoliciesToExistingTable = addPoliciesToExistingTable;
-const harness_1 = require("@agentic-kit/harness");
-const provision_helpers_1 = require("./provision-helpers");
-const SUPPORTED_CATEGORIES = new Set([
-    'has-module',
-    'no-fields',
-    'needs-table',
-]);
-class UnsupportedPolicyCategoryError extends Error {
-    policyType;
-    category;
-    constructor(policyType, category) {
-        super(`Policy type "${policyType}" has category "${category}" which requires column creation or composite handling — use the policies UI instead.`);
-        this.policyType = policyType;
-        this.category = category;
-        this.name = 'UnsupportedPolicyCategoryError';
-    }
-}
-exports.UnsupportedPolicyCategoryError = UnsupportedPolicyCategoryError;
-async function addPoliciesToExistingTable(input) {
-    const { client } = input;
-    for (const entry of input.policies) {
-        const category = (0, harness_1.getPolicyCategory)(entry.policyType);
-        if (!SUPPORTED_CATEGORIES.has(category)) {
-            throw new UnsupportedPolicyCategoryError(entry.policyType, category);
-        }
-    }
-    const policiesArray = [];
-    const nodesByType = new Map();
-    for (const entry of input.policies) {
-        const groups = (0, provision_helpers_1.groupOperationsByConfig)(entry.enabledOperations ?? provision_helpers_1.CRUD_OPERATIONS, entry.operations);
-        for (const group of groups) {
-            const ops = group.privileges.join('_');
-            const rand = Math.random().toString(36).slice(2, 8);
-            policiesArray.push((0, provision_helpers_1.buildPolicyEntry)(entry.policyType, {
-                privileges: group.privileges,
-                policy_role: group.roleName,
-                permissive: group.isPermissive,
-                data: entry.sharedPolicyData,
-                policy_name: `${ops}_${rand}`,
-            }));
-        }
-        if (entry.dataNodeType && !nodesByType.has(entry.dataNodeType)) {
-            const nodeData = entry.nodeData ?? {};
-            nodesByType.set(entry.dataNodeType, {
-                $type: entry.dataNodeType,
-                ...(Object.keys(nodeData).length > 0 ? { data: nodeData } : {}),
-            });
-        }
-    }
-    const provisionInput = {
-        databaseId: input.databaseId,
-        schemaId: input.schemaId,
-        tableId: input.tableId,
-        grants: (0, provision_helpers_1.buildGrants)(),
-        policies: policiesArray,
-    };
-    if (nodesByType.size > 0) {
-        provisionInput.nodes = [...nodesByType.values()];
-    }
-    await client.secureTableProvision
-        .create({
-        data: provisionInput,
-        select: { id: true, tableId: true, tableName: true },
-    })
-        .unwrap();
-    return { success: true };
-}

package/policy/provision-helpers.d.ts

@@ -1,38 +0,0 @@
-export type CrudOperation = 'create' | 'read' | 'update' | 'delete';
-export interface OperationPolicyConfig {
-    roleName: string;
-    isPermissive: boolean;
-    policyData: Record<string, unknown>;
-    isCustomized: boolean;
-}
-export interface CrudPolicyConfigs {
-    create: OperationPolicyConfig;
-    read: OperationPolicyConfig;
-    update: OperationPolicyConfig;
-    delete: OperationPolicyConfig;
-}
-export declare const CRUD_OPERATIONS: CrudOperation[];
-export type GrantPrivilege = [string, string | string[]];
-export interface GrantEntry {
-    roles: string[];
-    privileges: GrantPrivilege[];
-}
-export interface PolicyEntry {
-    $type: string;
-    data?: Record<string, unknown>;
-    privileges?: string[];
-    policy_role?: string;
-    permissive?: boolean;
-    policy_name?: string;
-}
-export declare const ALL_CRUD_PRIVILEGES: GrantPrivilege[];
-export declare function crudOpToPrivilege(op: CrudOperation): string;
-export declare function crudOpsToPrivileges(ops: readonly CrudOperation[]): string[];
-export declare function buildGrants(roles?: string[], privileges?: GrantPrivilege[]): GrantEntry[];
-export declare function buildPolicyEntry(type: string, opts?: Partial<Omit<PolicyEntry, '$type'>>): PolicyEntry;
-export interface OperationGroup {
-    roleName: string;
-    isPermissive: boolean;
-    privileges: string[];
-}
-export declare function groupOperationsByConfig(enabledOperations: readonly CrudOperation[], operations: CrudPolicyConfigs): OperationGroup[];

package/policy/provision-helpers.js

@@ -1,58 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ALL_CRUD_PRIVILEGES = exports.CRUD_OPERATIONS = void 0;
-exports.crudOpToPrivilege = crudOpToPrivilege;
-exports.crudOpsToPrivileges = crudOpsToPrivileges;
-exports.buildGrants = buildGrants;
-exports.buildPolicyEntry = buildPolicyEntry;
-exports.groupOperationsByConfig = groupOperationsByConfig;
-exports.CRUD_OPERATIONS = ['create', 'read', 'update', 'delete'];
-exports.ALL_CRUD_PRIVILEGES = [
-    ['select', '*'],
-    ['insert', '*'],
-    ['update', '*'],
-    ['delete', '*'],
-];
-const CRUD_OP_TO_LOWER_PRIVILEGE = {
-    create: 'insert',
-    read: 'select',
-    update: 'update',
-    delete: 'delete',
-};
-function crudOpToPrivilege(op) {
-    return CRUD_OP_TO_LOWER_PRIVILEGE[op];
-}
-function crudOpsToPrivileges(ops) {
-    return ops.map(crudOpToPrivilege);
-}
-function buildGrants(roles = ['authenticated'], privileges = exports.ALL_CRUD_PRIVILEGES) {
-    return [{ roles, privileges }];
-}
-function buildPolicyEntry(type, opts = {}) {
-    const entry = { $type: type };
-    if (opts.data && Object.keys(opts.data).length > 0)
-        entry.data = opts.data;
-    if (opts.privileges && opts.privileges.length > 0)
-        entry.privileges = opts.privileges;
-    if (opts.policy_role)
-        entry.policy_role = opts.policy_role;
-    if (opts.permissive !== undefined)
-        entry.permissive = opts.permissive;
-    if (opts.policy_name)
-        entry.policy_name = opts.policy_name;
-    return entry;
-}
-function groupOperationsByConfig(enabledOperations, operations) {
-    const groupMap = new Map();
-    for (const op of enabledOperations) {
-        const config = operations[op];
-        const key = `${config.roleName}:${config.isPermissive}`;
-        let group = groupMap.get(key);
-        if (!group) {
-            group = { roleName: config.roleName, isPermissive: config.isPermissive, privileges: [] };
-            groupMap.set(key, group);
-        }
-        group.privileges.push(...crudOpsToPrivileges([op]));
-    }
-    return [...groupMap.values()];
-}

package/provision-database/credential.d.ts

@@ -1,14 +0,0 @@
-export type AccountCredential = {
-    userId: string;
-    accessToken: string;
-    apiKey?: string;
-};
-export type ProvisionCredential = {
-    mode: 'account';
-    ownerId: string;
-    bearer: string;
-} | {
-    mode: 'error';
-    reason: string;
-};
-export declare function selectProvisionCredential(account: AccountCredential | null | undefined, signInHint?: string): ProvisionCredential;

package/provision-database/credential.js

@@ -1,22 +0,0 @@
-"use strict";
-// Pure: decide which credential authenticates a project's provisioning. Under the
-// account gate a signed-in session is guaranteed, so every new project provisions
-// UNDER the account (account-owned + enumerable): the database's owner_id is the
-// account's own userId, and the account's API key (falling back to its session
-// token) is the bearer that authenticates the provision mutation and lands in the
-// project .env as ACCESS_TOKEN (refreshed on every provision run, including the
-// skip path). A signed-in session with no usable bearer (keychain locked) is an
-// explicit error, never a silent throwaway owner.
-// Side-effect-free so the branch is unit-testable without runtime/network.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.selectProvisionCredential = selectProvisionCredential;
-function selectProvisionCredential(account, signInHint) {
-    const bearer = account?.apiKey ?? account?.accessToken;
-    if (account?.userId && bearer) {
-        return { mode: 'account', ownerId: account.userId, bearer };
-    }
-    return {
-        mode: 'error',
-        reason: `No usable account credential. ${signInHint ?? 'Sign in (or unlock your session) before provisioning a database.'}`,
-    };
-}

package/provision-database/env-file.d.ts

@@ -1,37 +0,0 @@
-export type EnvVars = Record<string, string>;
-/**
- * Upsert `vars` into the existing `.env` `content`. Existing keys are replaced
- * in place (preserving surrounding lines/comments); new keys are appended.
- * Returns the new file body, trailing-newline-terminated.
- */
-export declare function mergeEnv(content: string, vars: EnvVars): string;
-/** The credential keys provision_database owns in a project's .env. */
-export declare const PROVISION_ENV_KEYS: readonly ["DATABASE_ID", "DATABASE_NAME", "OWNER_ID", "ACCESS_TOKEN", "PGDATABASE", "API_ENDPOINT", "MODULES_ENDPOINT"];
-/**
- * Keys archived as comments on reprovision — the binding identity: which
- * database, under whom, on which backend. ACCESS_TOKEN is the account login
- * token, identical across bindings, so it is overwritten in place rather than
- * archived.
- */
-export declare const ARCHIVED_BINDING_KEYS: readonly ["DATABASE_ID", "DATABASE_NAME", "OWNER_ID", "PGDATABASE", "API_ENDPOINT", "MODULES_ENDPOINT"];
-/**
- * Build the provisioning credential block written to a project's .env. The
- * endpoint pins record which backend owns this binding — outside-app consumers
- * (verify-feature.sh, skill scripts, dev-server shells) resolve them instead of
- * falling back to localhost defaults when the app targets a hosted backend.
- */
-export declare function provisionEnvVars(args: {
-    databaseId: string;
-    databaseName: string;
-    ownerId: string;
-    accessToken: string;
-    apiEndpoint: string;
-    modulesEndpoint: string;
-}): EnvVars;
-/**
- * Comment out the given keys in place (`# archived <date>: KEY=value`) so a
- * reprovision keeps the previous binding readable in the file instead of
- * silently overwriting it. Every other line — including existing comments and
- * already-archived entries — passes through untouched.
- */
-export declare function archiveBindingKeys(content: string, keys: readonly string[], archivedOn: string): string;