@isomorph.ai/cli 0.4.2 → 0.5.1

package/dist/packages/harbour-cli/src/package.js

@@ -0,0 +1,101 @@
+import { homedir } from "node:os";
+import { basename, isAbsolute, join, parse, relative, resolve, sep } from "node:path";
+import { lstat, readdir, readFile, writeFile } from "node:fs/promises";
+import { scanWorkspace } from "../../../src/analyzer.js";
+import { sha256Bytes } from "../../../src/digest.js";
+import { isEnvExamplePath, isProhibitedSecretPath } from "../../../src/secret-paths.js";
+import { archiveForManifest } from "./upload.js";
+import { CliError } from "./output.js";
+import { readKitLock } from "./kit.js";
+/** Where `isomorph package` writes the console import package unless `--out` says otherwise. */
+export const PACKAGE_FILE = "isomorph-import.zip";
+export const PACKAGE_NEXT_STEP = `Upload ${PACKAGE_FILE} in the Isomorph console (Add app → Upload package), or connect the repository there instead.`;
+/** A real env file (`.env`, `.env.local`, `.env.staging`), never a checked-in template. */
+export const isEnvFile = (path) => /(^|\/)\.env(?:\.[^/]+)?$/i.test(path) && !isEnvExamplePath(path);
+/** The filesystem root and the person's home are never an app. Cheap, so both `deploy` and `package` ask before reading anything. */
+export function assertSafeAppRoot(root) {
+    if (root === parse(root).root || root === resolve(homedir()))
+        throw new CliError("PREFLIGHT_APP_ROOT", "The selected app boundary is unsafe.");
+}
+/**
+ * The pre-flight `deploy` and `package` share: the same ignore-aware scan
+ * (`node_modules`, build output, caches and `.git` stay out), the same refusal
+ * of an empty boundary and of a secret-bearing path, then every file read once.
+ *
+ * `envFiles` is the one difference between the two: a deploy carries no env
+ * file (the scanner drops `.env` and refuses `.env.<anything>`), while the
+ * console import wants them — it reads their values into encrypted defaults
+ * and never commits the files — so `package` walks the tree for them and admits
+ * them past the secret-path refusal. Private keys and the like are refused on
+ * both paths. `exclude` keeps a package's own output out of the next package.
+ */
+export async function readAppTree(root, options = {}) {
+    assertSafeAppRoot(root);
+    const graph = await scanWorkspace(root, { sourceBoundary: "root" });
+    const excluded = new Set(options.exclude ?? []);
+    const permitted = (path) => Boolean(options.envFiles) && isEnvFile(path);
+    const included = graph.deploymentScope.includedFiles.filter(path => !excluded.has(path));
+    if (!included.length)
+        throw new CliError("PREFLIGHT_EMPTY", "The selected app boundary contains no eligible files.");
+    if (included.some(path => isProhibitedSecretPath(path) && !permitted(path)))
+        throw new CliError("PREFLIGHT_SECRET_PATH", "The selected app boundary contains a prohibited secret file.");
+    const paths = options.envFiles ? [...new Set([...included, ...await envFilesIn(root, graph.deploymentScope.excludedDirectories)])].filter(path => !excluded.has(path)).sort() : included;
+    const files = await Promise.all(paths.map(async (path) => ({ path, content: new Uint8Array(await readFile(resolve(root, path))) })));
+    return { graph, files };
+}
+/**
+ * The env files the scanner leaves out, found the way it walks: directories it
+ * ignores are ignored here, symlinks are skipped, paths are relative and
+ * slash-separated.
+ */
+async function envFilesIn(root, ignoredDirectories) {
+    const ignored = new Set([...ignoredDirectories, ".git"]);
+    const found = [];
+    const walk = async (directory) => {
+        for (const entry of await readdir(directory, { withFileTypes: true })) {
+            if (entry.isSymbolicLink())
+                continue;
+            const absolute = join(directory, entry.name);
+            if (entry.isDirectory()) {
+                if (!ignored.has(entry.name))
+                    await walk(absolute);
+                continue;
+            }
+            if (entry.isFile() && isEnvFile(entry.name))
+                found.push(relative(root, absolute).split(sep).join("/"));
+        }
+    };
+    await walk(root);
+    return found;
+}
+/**
+ * `isomorph package`: the app as it is, zipped for the console's Upload
+ * package. Local — no company, no sign-in, no kit: a kit app is refused,
+ * because it deploys from here with `isomorph deploy`. The zip is deterministic
+ * (no timestamps), so the same tree gives the same sha256 twice.
+ */
+export async function packageApp(rootArg, output, options = {}) {
+    const root = resolve(rootArg);
+    if (!(await lstat(root).then(info => info.isDirectory(), () => false)))
+        throw new CliError("APP_ROOT_MISSING", `${rootArg} is not a folder.`, undefined, "Pass --app-root <the app's folder>.");
+    if (await readKitLock(root))
+        throw new CliError("KIT_APP", "This folder is an Isomorph kit app; it does not go through the console import.", undefined, `Kit apps deploy with \`isomorph deploy --app-root ${rootArg}\`.`);
+    const out = options.out ? resolve(options.out) : join(root, PACKAGE_FILE);
+    // A package is never app content: neither the one written last time under the
+    // default name nor this one when --out puts it inside the app.
+    const outInside = relative(root, out);
+    const exclude = [PACKAGE_FILE, ...(outInside && !outInside.startsWith("..") && !isAbsolute(outInside) ? [outInside.split(sep).join("/")] : [])];
+    output(`Isomorph is packaging ${basename(root)}.`);
+    const tree = await readAppTree(root, { exclude, envFiles: true });
+    const envCount = tree.files.filter(file => isEnvFile(file.path)).length;
+    output(`Isomorph found ${tree.files.length} app files${envCount ? ` (${envCount} .env file${envCount === 1 ? "" : "s"} included: the console stores their values encrypted and never commits them)` : ""}.`);
+    // The file list, hashed as a deploy manifest hashes it. Not `createSourceManifest`:
+    // that validates with the server's staging rule, which refuses every real env file —
+    // right for what reaches source control, and exactly what the console import
+    // reads out of the package before that rule runs. Nothing here is sent.
+    const files = await Promise.all(tree.files.map(async (file) => ({ path: file.path, sha256: await sha256Bytes(file.content), bytes: file.content.byteLength })));
+    const archive = await archiveForManifest(root, { files }, { permit: isEnvFile });
+    await writeFile(out, archive.body);
+    output(`Package written: ${out} (${files.length} files, ${archive.body.byteLength} bytes, ${archive.digest}).`);
+    return { path: out, files: files.length, bytes: archive.body.byteLength, sha256: archive.digest, nextStep: PACKAGE_NEXT_STEP };
+}

package/dist/packages/harbour-cli/src/starter.js

@@ -1,4 +1,4 @@
-import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
+import { mkdir, readdir, readFile, stat, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { bundleDiff } from "./kit-bundle.js";
 import { agentSetup, MANAGED_END, MANAGED_START, upsertManagedBlock } from "./agent-setup.js";
@@ -6,19 +6,46 @@ import { defaultAppProfile, emptyDeclaration, newKitLock, readKitLock, renderApp
 import { CliError } from "./output.js";
 export { MANAGED_END, MANAGED_START };
 /**
- * Creates the starter in an empty directory, or adds the missing kit files to
- * an existing Vite + React app. User files are never overwritten: a path that
- * exists is reported as kept. Instruction files get a managed block that points at the
- * rules, and the user-level agent guide (the rules themselves) is installed so the
- * agents know the kit from any folder.
+ * Files and folders that do not make a folder "an app": what an editor, git or an
+ * agent leaves in an otherwise empty folder. Anything else is content, and content
+ * without a kit lock is an app that was built without the kit.
+ */
+const IGNORABLE_ENTRIES = new Set([".git", ".DS_Store", ".gitignore", "README.md", "LICENSE", "CLAUDE.md", "AGENTS.md", ".claude", ".codex", ".vscode", ".idea"]);
+/** The three ways forward for a folder with an app and no kit, as the `APP_EXISTS` refusal carries them (`details.choices`). */
+export function appExistsChoices(dir) {
+    return [
+        { id: "adopt", command: `isomorph init --app-root ${dir} --adopt`, description: "add the kit to this app in place; Vite + React only" },
+        { id: "new", command: "isomorph init --app-root <new-empty-folder>", description: "start a new kit app in a new empty folder" },
+        { id: "package", command: `isomorph package --app-root ${dir}`, description: "package this app as it is for import in the Isomorph console" }
+    ];
+}
+/**
+ * Creates the starter in an empty directory, adds the missing kit files to an
+ * existing Vite + React app (`adopt`), or keeps a kit app as it is. A folder
+ * with an app and no kit is never adopted silently: the refusal names the
+ * three choices and the agent relays them to the person. User files are never
+ * overwritten: a path that exists is reported as kept. Instruction files get a
+ * managed block that points at the rules, and the user-level agent guide (the
+ * rules themselves) is installed so the agents know the kit from any folder.
  */
 export async function initKit(root, bundle, options = {}) {
     await mkdir(root, { recursive: true });
     const existingPackage = await readJson(join(root, "package.json"));
-    const emptyDir = !existingPackage && !(await exists(join(root, "src")));
-    if (existingPackage && !isSupportedApp(existingPackage))
-        throw new CliError("APP_UNSUPPORTED", "isomorph init supports an empty directory or an existing Vite + React app (package.json must depend on vite and react).", undefined, "Run `isomorph init --app-root <new-empty-folder>` to start a Vite + React app, then move this app's code into it.");
-    const result = { root, created: [], kept: [], updated: [], mode: options.upgrade ? "upgrade" : emptyDir ? "starter" : "existing", bundleChanges: [], agents: options.env ? await agentSetup(options.env) : { created: [], updated: [], kept: [], removed: [] } };
+    const previous = await readKitLock(root);
+    const emptyDir = (await readdir(root)).every(name => IGNORABLE_ENTRIES.has(name));
+    const unsupported = () => new CliError("APP_UNSUPPORTED", "isomorph init supports an empty directory or an existing Vite + React app (package.json must depend on vite and react).", undefined, "Run `isomorph init --app-root <new-empty-folder>` to start a Vite + React app, then move this app's code into it.");
+    if (!emptyDir && !previous && !options.upgrade) {
+        // Refused before anything is written, here or in the person's home: the choice is theirs.
+        const dir = options.displayRoot ?? root;
+        const choices = appExistsChoices(dir);
+        if (!options.adopt)
+            throw new CliError("APP_EXISTS", "This folder already has an app and no Isomorph kit.", undefined, "Choose one of the three commands below: add the kit to this app in place (--adopt, Vite + React only), start a new kit app in an empty folder, or package this app as it is for the console import.", undefined, { details: { choices } });
+        if (!existingPackage || !isSupportedApp(existingPackage))
+            throw unsupported();
+    }
+    else if (existingPackage && !isSupportedApp(existingPackage))
+        throw unsupported();
+    const result = { root, created: [], kept: [], updated: [], mode: options.upgrade ? "upgrade" : previous ? "kit" : emptyDir ? "starter" : "existing", bundleChanges: [], agents: options.env ? await agentSetup(options.env) : { created: [], updated: [], kept: [], removed: [] } };
     const write = async (path, content) => {
         const absolute = join(root, path);
         if (await exists(absolute)) {
@@ -37,7 +64,6 @@ export async function initKit(root, bundle, options = {}) {
     await appendManaged(root, ".gitignore", GITIGNORE_LINES, result, "\n");
     for (const file of ["CLAUDE.md", "AGENTS.md"])
         await appendManaged(root, file, managedBlock(), result, "\n\n", MANAGED_START, MANAGED_END);
-    const previous = await readKitLock(root);
     if (!previous) {
         await writeKitLock(root, newKitLock(bundle, options.tenantId ?? ""));
         result.created.push(".isomorph/kit.lock.json");
@@ -82,7 +108,7 @@ async function appendManaged(root, file, block, result, separator, start, end) {
 const exists = (path) => stat(path).then(() => true, () => false);
 const readJson = (path) => readFile(path, "utf8").then(text => JSON.parse(text), () => undefined);
 // ---- Templates -----------------------------------------------------------------
-const GITIGNORE_LINES = ["node_modules/", "dist/", ".isomorph/local/"].join("\n");
+const GITIGNORE_LINES = ["node_modules/", "dist/", ".isomorph/local/", ".isomorph/checks/"].join("\n");
 /**
  * The per-app block: it says where the rules are and when to read each, and nothing
  * else — the rules themselves live in the modules `agent-setup` writes beside the
@@ -128,14 +154,10 @@ function kitFiles(root) {
  * `notes` table it never had, and a check that queries it then fails `flow` on
  * the next deploy (#456).
  *
- * The retained checks are deliberately not here, and not written by `init` at
- * all. `isomorph check` generates them from this schema — read back out of the
- * database it replays the migrations into — and from this source, so "one
- * journey per capability the UI declares, plus the cross-user denial per
- * owner-scoped table" is a property of the generator rather than three files
- * that have to be kept in step with `src/App.tsx` by hand. `init` has no
- * database and so invents nothing: `.isomorph/checks/` arrives with the first
- * `isomorph check`, which is also the command that keeps it right afterwards.
+ * No checks are here either: `.isomorph/checks/` is generated output the kit
+ * gate rebuilds on every `isomorph check` from this schema (read back out of
+ * the database it replays the migrations into) and this source, gitignored by
+ * `init`; a check the builder writes lives in `tests/<name>.mjs`.
  */
 function starterFiles(bundle) {
     return {
@@ -167,14 +189,14 @@ Created by \`isomorph init\`: a Vite + React app that runs on Isomorph. Sign-in,
 ## Three commands
 
 - \`isomorph dev --app-root . --detach --json\` — starts the app on this machine with a local database, file store and gateway; open the printed link.
-- \`isomorph check --app-root . --json\` — the same gates the deployment pipeline runs (types, build, schema, retained checks); the output is the report.
+- \`isomorph check --app-root . --json\` — the same gates the deployment pipeline runs (types, build, schema, journeys); the output is the report.
 - \`isomorph deploy --app-root . --json\` — deploys a private preview for the people named in \`.isomorph/app.json\`; \`isomorph promote\` makes it live for everyone once they have tried it.
 
 ## Where the rules are
 
 The kit's rules are in the \`isomorph\` skill that \`isomorph agent-setup\` installs for Claude Code (\`~/.claude/skills/isomorph/\`) and Codex (\`~/.codex/skills/isomorph/\`): \`core.md\` (identity, data, files, realtime, commands, error codes), \`integrations.md\` (Slack, Gmail, warehouse), \`ai.md\` and \`jobs.md\`. The managed block in CLAUDE.md / AGENTS.md points there.
 
-\`.isomorph/checks/\` is generated by \`isomorph check\` from \`migrations/\` and \`src/\` — do not write it by hand. \`.isomorph/integrations.json\` declares the company systems the app calls: none, to start. \`.isomorph/app.json\` holds the app's name, description and audience.
+\`.isomorph/checks/\` is regenerated on each check and gitignored — put your own checks in \`tests/<name>.mjs\`. \`.isomorph/integrations.json\` declares the company systems the app calls: none, to start. \`.isomorph/app.json\` holds the app's name, description and audience.
 `;
 const VITE_CONFIG = `import { defineConfig } from "vite";
 import react from "@vitejs/plugin-react";

package/dist/packages/harbour-cli/src/upload.js

@@ -3,14 +3,20 @@ import { relative, resolve, sep } from "node:path";
 import { deflateRawSync } from "node:zlib";
 import { sha256Bytes } from "../../../src/digest.js";
 import { isProhibitedSecretPath } from "../../../src/secret-paths.js";
-export async function archiveForManifest(root, manifest) {
+/**
+ * The deterministic package for a manifest. Secret-bearing paths are refused
+ * unless `permit` admits one: the console import (`isomorph package`) carries
+ * the app's `.env` files on purpose, because the console reads their values
+ * into encrypted defaults and never commits the files; a deploy carries none.
+ */
+export async function archiveForManifest(root, manifest, options = {}) {
     const rootAbsolute = resolve(root);
     if ((await lstat(rootAbsolute)).isSymbolicLink())
         throw new Error("Isomorph rejected an unsafe app boundary.");
     const files = [];
     const seen = new Set();
     for (const entry of manifest.files) {
-        if (seen.has(entry.path) || isProhibitedSecretPath(entry.path) || entry.path.includes("\\") || entry.path.startsWith("/"))
+        if (seen.has(entry.path) || (isProhibitedSecretPath(entry.path) && !options.permit?.(entry.path)) || entry.path.includes("\\") || entry.path.startsWith("/"))
             throw new Error("Isomorph rejected an unsafe source path.");
         seen.add(entry.path);
         const absolute = resolve(rootAbsolute, entry.path);

package/dist/src/analyzer.js

@@ -13,10 +13,9 @@ const MAX_FILE_BYTES = 256_000;
 // application files. Keeping them out also makes reruns idempotent after a
 // previous save has written a receipt into the selected workspace.
 const IGNORED_DIRS = new Set([".git", ".harbour", ".isomorph", ".next", ".nuxt", ".svelte-kit", ".turbo", "coverage", "dist", "build", "node_modules", "vendor"]);
-/** The development kit's directory. It commits its declaration, lock, governed-AI inventory and journey checks there (see `isKitCommittedPath`); everything else in it (local state, checks evidence, generated control files) stays out of the package. The inventory is what the pipeline plans a kit app's AI over (data plane 0.78.2.0): the gate writes it under `isomorph check`, the lane refuses an app whose source calls governed AI without it. */
+/** The development kit's directory. It commits its declaration, lock and app profile there (see `isKitCommittedPath`); everything else in it stays out of the package — local state, and the generated `checks/` and `ai-inventory.json`, which the pipeline's kit lane regenerates from the source it builds (data plane ADR 0014). */
 const KIT_DIR = ".isomorph";
-const KIT_CONTROL_FILES = [`${KIT_DIR}/integrations.json`, `${KIT_DIR}/kit.lock.json`, `${KIT_DIR}/app.json`, `${KIT_DIR}/ai-inventory.json`];
-const KIT_CHECKS_DIR = `${KIT_DIR}/checks`;
+const KIT_CONTROL_FILES = [`${KIT_DIR}/integrations.json`, `${KIT_DIR}/kit.lock.json`, `${KIT_DIR}/app.json`];
 const SECRET_FILE_NAMES = new Set([".env", ".env.local", ".env.production", ".env.development", ".npmrc"]);
 const TEXT_EXTENSIONS = new Set([".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs", ".json", ".html", ".css", ".py", ".rb", ".go", ".rs", ".java", ".cs", ".php", ".md", ".toml", ".yaml", ".yml", ".sh"]);
 function normalizeIncludePath(value) {
@@ -90,20 +89,7 @@ async function collectFiles(root, current, output, unknowns) {
     }
 }
 async function collectKitFiles(root, output) {
-    const paths = [...KIT_CONTROL_FILES];
-    let checks = [];
-    try {
-        checks = await readdir(join(root, ...KIT_CHECKS_DIR.split("/")), { withFileTypes: true });
-    }
-    catch {
-        checks = [];
-    }
-    for (const entry of checks) {
-        const path = `${KIT_CHECKS_DIR}/${entry.name}`;
-        if (isKitCommittedPath(path))
-            paths.push(path);
-    }
-    for (const path of paths.sort()) {
+    for (const path of KIT_CONTROL_FILES) {
         const absolute = join(root, ...path.split("/"));
         let info;
         try {

package/dist/src/secret-paths.js

@@ -19,14 +19,14 @@ export function isSourceIntakeExcludedPath(path) {
 }
 /**
  * The development kit commits exactly these files under `.isomorph`: the
- * integrations declaration, the kit lock, the governed-AI inventory, and the
- * journey checks directly in `.isomorph/checks/` as `.mjs`, `.js` or `.cjs`
- * modules (no subdirectories, no other extensions — evidence and reports
- * written next to them stay local). Everything else there (local state,
- * generated control files) stays local.
+ * integrations declaration, the kit lock and the app profile. Everything else
+ * there stays local — local state, and the generated `checks/` and
+ * `ai-inventory.json`, which the pipeline's kit lane regenerates from the
+ * source it builds (data plane ADR 0014); a builder's own checks are
+ * `tests/*.mjs` at the app root, ordinary source.
  */
 export function isKitCommittedPath(path) {
-    return /(^|\/)\.isomorph\/(?:integrations\.json|kit\.lock\.json|app\.json|ai-inventory\.json|checks\/[^/]+\.(?:mjs|js|cjs))$/.test(path);
+    return /(^|\/)\.isomorph\/(?:integrations\.json|kit\.lock\.json|app\.json)$/.test(path);
 }
 /**
  * Dependency and internal directories the intake never stages: `node_modules`,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@isomorph.ai/cli",
-  "version": "0.4.2",
+  "version": "0.5.1",
   "description": "Isomorph development kit CLI",
   "type": "module",
   "bin": {
@@ -37,7 +37,7 @@
   "harbour": {
     "kitBundle": {
       "repository": "public.ecr.aws/y6t4p3i8/harbour-kit-bundle",
-      "version": "0.4.0"
+      "version": "0.5.1"
     }
   }
 }

package/dist/packages/harbour-cli/src/app-schema.js

@@ -1,150 +0,0 @@
-import { readFile, readdir } from "node:fs/promises";
-import { join } from "node:path";
-/**
- * A policy that decides rows by the signed-in identity, and the column it decides them on.
- * `IDENTITY` is rule `core.rls-owner-scoped` (guide.ts): any policy text naming the
- * identity setting makes the table private, so a shared-read table keeps it out of SELECT.
- */
-const OWNER_SCOPE = /([A-Za-z_][A-Za-z0-9_]*)\s*(?:\)|::[a-z ]+)*\s*=\s*current_setting\('harbour\.user_(?:id|email)'/i;
-const IDENTITY = /current_setting\('harbour\.user_(?:id|email)'/i;
-/**
- * The app's tables as the database holds them, from the catalog the kit gate
- * read after replaying the migrations, or `undefined` when that text is not a
- * catalog. `undefined` is not "no tables": nothing is generated from, or
- * removed because of, a schema Isomorph could not read — deleting an app's
- * retained checks on a failed query would be the worst possible reading of it.
- */
-export async function readAppSchema(catalogText, root) {
-    const text = catalogText.trim();
-    if (!text.startsWith("["))
-        return undefined;
-    let catalog;
-    try {
-        catalog = JSON.parse(text);
-    }
-    catch {
-        return undefined;
-    }
-    if (!Array.isArray(catalog))
-        return undefined;
-    const migrations = await migrationTexts(root);
-    const schema = new Map();
-    for (const table of catalog) {
-        schema.set(table.name, {
-            columns: table.columns.map(column => ({
-                name: column.name,
-                type: columnType(column.base, column.category),
-                declaredType: column.type,
-                notNull: column.notnull,
-                hasDefault: column.default !== null,
-                generated: column.generated,
-                identityDefault: IDENTITY.test(column.default ?? ""),
-                references: column.fk,
-                checks: column.checks
-            })),
-            primaryKey: table.primaryKey,
-            ownerScoped: table.policies.some(policy => IDENTITY.test(policy)),
-            ownerColumn: table.policies.map(policy => OWNER_SCOPE.exec(policy)?.[1]).find(Boolean),
-            file: createdIn(table.name, migrations)
-        });
-    }
-    return schema;
-}
-/**
- * Postgres has already reduced every declared spelling to one base type name
- * (`character varying` to `varchar`, `double precision` to `float8`, `BIGSERIAL`
- * to `int8` with a nextval default), so this is a lookup rather than a parse.
- */
-function columnType(base, category) {
-    if (category === "A")
-        return "array";
-    switch (base) {
-        case "text":
-        case "varchar":
-        case "bpchar":
-        case "char":
-        case "citext":
-        case "name": return "text";
-        case "uuid": return "uuid";
-        case "bool": return "boolean";
-        case "int2":
-        case "int4":
-        case "int8": return "integer";
-        case "numeric":
-        case "float4":
-        case "float8":
-        case "money": return "number";
-        case "timestamptz":
-        case "timestamp": return "timestamptz";
-        case "date": return "date";
-        case "time":
-        case "timetz": return "time";
-        case "json":
-        case "jsonb": return "json";
-        default: return "unknown";
-    }
-}
-async function migrationTexts(root) {
-    const directory = join(root, "migrations");
-    const names = (await readdir(directory).catch(() => [])).filter(name => name.endsWith(".sql")).sort();
-    return Promise.all(names.map(async (name) => ({ name: `migrations/${name}`, text: await readFile(join(directory, name), "utf8").catch(() => "") })));
-}
-/** Which file created a table: the only question the catalog cannot answer, so the only one still asked of the SQL text. */
-function createdIn(table, migrations) {
-    const pattern = new RegExp(String.raw `create\s+table\b[^;]*\b${table}\b`, "i");
-    return migrations.find(migration => pattern.test(migration.text))?.name ?? "migrations/";
-}
-// ---- CHECK constraints ----------------------------------------------------------
-//
-// `pg_get_constraintdef` deparses, so these read one normal form rather than
-// everything an author might have typed: `BETWEEN a AND b` has already become
-// `>= a AND <= b`, `IN (…)` has become `= ANY (ARRAY[…])`, and each operand
-// carries its cast. Only the shapes a value has to satisfy to be accepted are
-// read; anything else is left alone, and a value the database rejects surfaces
-// as a failing journey under `isomorph check` in seconds rather than in the
-// pipeline minutes later.
-/** `char_length(col) >= n`, `length(col) <= n` — including the `((col)::text)` spelling a deparse gives a varchar. */
-export function textLengthBounds(checks, column) {
-    let min = 1;
-    let max = 500;
-    const pattern = new RegExp(String.raw `(?:char_length|length|octet_length)\([^<>=]*\b${column}\b[^<>=]*(<=|<|>=|>|=)\s*(\d+)`, "gi");
-    for (const check of checks)
-        for (const match of check.matchAll(pattern)) {
-            const value = Number(match[2]);
-            if (match[1] === "<=" || match[1] === "=")
-                max = Math.min(max, value);
-            else if (match[1] === "<")
-                max = Math.min(max, value - 1);
-            else if (match[1] === ">=")
-                min = Math.max(min, value);
-            else
-                min = Math.max(min, value + 1);
-        }
-    return { min, max: Math.max(max, min) };
-}
-/** `col = ANY (ARRAY['a'::text, 'b'::text])`: the closed set a value must come from. */
-export function allowedLiterals(checks, column) {
-    for (const check of checks) {
-        const list = new RegExp(String.raw `\b${column}\b[^=]*=\s*ANY\s*[\s(]*ARRAY\[([^\]]*)\]`, "i").exec(check);
-        const values = [...(list?.[1] ?? "").matchAll(/'((?:[^']|'')*)'/g)].map(match => match[1].replace(/''/g, "'"));
-        if (values.length)
-            return values;
-    }
-    return [];
-}
-/** The smallest number `col > n` / `col >= n` accepts. */
-export function numericMinimum(checks, column) {
-    let minimum = 1;
-    for (const check of checks) {
-        const comparison = new RegExp(String.raw `\b${column}\b[^<>=]*(>=|>)\s*(-?\d+(?:\.\d+)?)`, "i").exec(check);
-        if (!comparison)
-            continue;
-        const value = Number(comparison[2]);
-        minimum = Math.max(minimum, comparison[1] === ">" ? value + 1 : value);
-    }
-    return minimum;
-}
-/** Whether `col <= n` / `col < n` caps the column: the mirror of `numericMinimum`, asked so no invented value is written into a range the app's own CHECK does not admit. */
-export function hasNumericMaximum(checks, column) {
-    return checks.some(check => new RegExp(String.raw `\b${column}\b[^<>=]*(?:<=|<)\s*-?\d+(?:\.\d+)?`, "i").test(check));
-}

package/dist/packages/harbour-cli/src/remote-mcp-client.js

@@ -1,135 +0,0 @@
-import { CLI_VERSION } from "./version.js";
-import { CliError } from "./output.js";
-/** The code for a refusal the server did not label. Its own words still reach
- * the builder; only the machine label is ours, and it says exactly that. */
-const UNLABELLED_REFUSAL = "ISOMORPH_REFUSED";
-/**
- * Isomorph labels part of its refusals `CODE: sentence` on the wire — `src/mcp.ts`
- * raises `APP_NOT_REGISTERED: …`, `SOURCE_UPLOAD_REQUIRED: …`, and the tool
- * result carries that text and nothing else. Lifting the prefix into `code` is
- * not classification: the label is the server's own, the sentence is kept
- * whole either way, and a miss only means the refusal goes out unlabelled.
- */
-const LABELLED = /^([A-Z][A-Z0-9_]{2,63}):[ \t]+(\S[\s\S]*)$/;
-function refusalText(result) {
-    return (result.content ?? []).map(item => item.text ?? "").join("\n").trim();
-}
-/**
- * A tool refusal, carried whole: the server's own code, its own sentence and
- * its own fix. `structuredContent` is read first because that is where a code
- * belongs and where the server will put one once `toolError` carries one; today
- * only the labelled prefix is available.
- */
-export function serverRefusal(result) {
-    const text = refusalText(result);
-    const detail = result.structuredContent && typeof result.structuredContent === "object" ? result.structuredContent : undefined;
-    const declared = typeof detail?.code === "string" ? detail.code.trim() : "";
-    const hint = typeof detail?.remediationHint === "string" && detail.remediationHint.trim() ? detail.remediationHint.trim() : undefined;
-    const labelled = declared ? null : LABELLED.exec(text);
-    return new CliError(declared || labelled?.[1] || UNLABELLED_REFUSAL, (labelled?.[2] ?? text) || "Isomorph rejected the request.", undefined, hint, undefined, { layer: "governance" });
-}
-/** A JSON-RPC error is Isomorph refusing the call itself (an unknown method, a
- * body it could not parse). Its numeric code is the only one it has, so it is
- * reported as such rather than flattened away. */
-function rpcRefusal(error, status) {
-    const text = error.message?.trim() ?? "";
-    const labelled = LABELLED.exec(text);
-    const code = labelled?.[1] ?? (typeof error.code === "number" ? `ISOMORPH_RPC_${error.code}` : `ISOMORPH_HTTP_${status}`);
-    return new CliError(code, (labelled?.[2] ?? text) || `Isomorph refused the request (HTTP ${status}).`, undefined, undefined, undefined, { layer: "governance" });
-}
-/**
- * A second 401 in a row: the sign-in itself is gone, or this company does not
- * admit the signed-in account. The server says which in `error_description`
- * (plain English, no URL or token); an older server sends only the code, and
- * the fixed sentence stands in. Both fixes are named because the builder cannot
- * tell the two causes apart: on 2026-09-14 a `deploy` 14 seconds after a
- * successful `isomorph login` was refused by a company the account was not a
- * member of, and "run login again" would only have repeated it.
- */
-async function signInRefused(response) {
-    const body = await response.json().catch(() => undefined);
-    const said = typeof body?.error_description === "string" ? body.error_description.trim() : "";
-    return new CliError("AUTH_REQUIRED", `${said || "Isomorph sign-in expired or was revoked."} Run \`isomorph login\` again, or \`isomorph connect <work-email-or-start-url>\` if this is the wrong company.`, undefined, undefined, undefined, { layer: "governance" });
-}
-async function readRpc(response) {
-    try {
-        return await response.json();
-    }
-    catch {
-        throw new Error(`Isomorph returned a response that was not JSON (HTTP ${response.status}).`);
-    }
-}
-export class RemoteMcpClient {
-    url;
-    tenant;
-    id = 0;
-    initialized = false;
-    token;
-    constructor(url, token, tenant) {
-        this.url = url;
-        this.tenant = tenant;
-        this.token = typeof token === "string" ? async () => token : token;
-    }
-    get endpoint() { return this.url; }
-    async initialize() {
-        if (this.initialized)
-            return;
-        await this.request("initialize", { protocolVersion: "2025-11-25", capabilities: {}, clientInfo: { name: "isomorph-cli", version: CLI_VERSION } });
-        await this.request("notifications/initialized", undefined, false);
-        this.initialized = true;
-    }
-    async call(name, args) {
-        const response = await this.request("tools/call", { name, arguments: args });
-        const result = response;
-        if (result.isError)
-            throw serverRefusal(result);
-        return result;
-    }
-    async request(method, params, expectResponse = true) {
-        const body = JSON.stringify({ jsonrpc: "2.0", id: ++this.id, method, ...(params === undefined ? {} : { params }) });
-        let response = await this.post(body);
-        // A 401 mid-command usually means the stored token was rotated by another
-        // process; re-resolve (which reloads the store) and retry once. A second
-        // 401 is Isomorph refusing the sign-in, and `signInRefused` says why.
-        if (response.status === 401)
-            response = await this.post(body);
-        if (response.status === 401)
-            throw await signInRefused(response);
-        if (!expectResponse)
-            return undefined;
-        const parsed = await readRpc(response);
-        if (parsed.error)
-            throw rpcRefusal(parsed.error, response.status);
-        // A non-ok response with no JSON-RPC error in it is the network between us
-        // and Isomorph, not Isomorph's answer, so it stays a plain Error: a long poll
-        // treats plain Errors as transient and tries again (see `waitForSettled`),
-        // and only `CliError` stops it. The wording is decided here rather than
-        // guessed from this string downstream.
-        if (!response.ok)
-            throw new Error(`Isomorph request failed (HTTP ${response.status}).`);
-        return parsed.result;
-    }
-    async post(body) {
-        const headers = { "content-type": "application/json", "mcp-protocol-version": "2025-11-25", "x-harbour-tenant": this.tenant };
-        const token = await this.token();
-        if (token)
-            headers.authorization = `Bearer ${token}`;
-        try {
-            return await fetch(this.url, { method: "POST", headers, body });
-        }
-        catch (error) {
-            // Plain Error for the same reason as the non-ok branch: a dropped
-            // connection mid-deployment is transient and the poll must be free to
-            // retry. `redact()` strips the URL before any of this is printed.
-            throw new Error(`Isomorph could not be reached (${error instanceof Error ? error.message : "no details"}).`);
-        }
-    }
-}
-export function structured(result) {
-    if (result.isError)
-        throw serverRefusal(result);
-    return result.structuredContent;
-}
-export function plainText(result) {
-    return result.content?.map(item => item.text ?? "").join("\n") ?? "";
-}