@wardby/cli 0.2.1 → 0.3.0

package/dist/generated/prisma/models/RunHostStatus.js

@@ -0,0 +1 @@
+export {};

package/dist/generated/prisma/models/Tool.d.ts

@@ -184,10 +184,11 @@ export type ToolOrderByWithRelationInput = {
 };
 export type ToolWhereUniqueInput = Prisma.AtLeast<{
     id?: string;
-    name?: string;
+    ownerId_name?: Prisma.ToolOwnerIdNameCompoundUniqueInput;
     AND?: Prisma.ToolWhereInput | Prisma.ToolWhereInput[];
     OR?: Prisma.ToolWhereInput[];
     NOT?: Prisma.ToolWhereInput | Prisma.ToolWhereInput[];
+    name?: Prisma.StringFilter<"Tool"> | string;
     description?: Prisma.StringFilter<"Tool"> | string;
     paramsZod?: Prisma.StringFilter<"Tool"> | string;
     jsonSchema?: Prisma.JsonFilter<"Tool">;
@@ -197,7 +198,7 @@ export type ToolWhereUniqueInput = Prisma.AtLeast<{
     ownerId?: Prisma.StringNullableFilter<"Tool"> | string | null;
     agents?: Prisma.AgentToolListRelationFilter;
     owner?: Prisma.XOR<Prisma.PrincipalNullableScalarRelationFilter, Prisma.PrincipalWhereInput> | null;
-}, "id" | "name">;
+}, "id" | "ownerId_name">;
 export type ToolOrderByWithAggregationInput = {
     id?: Prisma.SortOrder;
     name?: Prisma.SortOrder;
@@ -306,6 +307,10 @@ export type ToolUncheckedUpdateManyInput = {
     updatedAt?: Prisma.DateTimeFieldUpdateOperationsInput | Date | string;
     ownerId?: Prisma.NullableStringFieldUpdateOperationsInput | string | null;
 };
+export type ToolOwnerIdNameCompoundUniqueInput = {
+    ownerId: string;
+    name: string;
+};
 export type ToolCountOrderByAggregateInput = {
     id?: Prisma.SortOrder;
     name?: Prisma.SortOrder;
@@ -648,6 +653,12 @@ export type $ToolPayload<ExtArgs extends runtime.Types.Extensions.InternalArgs =
     };
     scalars: runtime.Types.Extensions.GetPayloadResult<{
         id: string;
+        /**
+         * Unique per owner (@@unique below), not globally: the name is what the
+         * model calls, so what must never repeat is a name within one agent's
+         * attachments — attach_tool, `wardby tool attach` and the importer refuse
+         * a second same-named tool on an agent.
+         */
         name: string;
         description: string;
         /**
@@ -660,7 +671,8 @@ export type $ToolPayload<ExtArgs extends runtime.Types.Extensions.InternalArgs =
          * and cached here — re-deriving it on every run would spin a fresh QuickJS
          * runtime and evaluate the whole vendored zod bundle per attached tool,
          * before the first LLM call, on every single run. Safe to cache because
-         * there's no "update tool" path — paramsZod can't change without a new row.
+         * every write of paramsZod (create, and MCP update_tool) re-derives it in
+         * the same write. A run pins the version its load step read.
          */
         jsonSchema: runtime.JsonValue;
         /**

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

@@ -10,10 +10,17 @@ export type * from './models/AgentMemory.js';
 export type * from './models/Run.js';
 export type * from './models/CodingAgentProfile.js';
 export type * from './models/CodingRun.js';
+export type * from './models/CodingService.js';
 export type * from './models/CodingProxySession.js';
 export type * from './models/CodingProxyRequest.js';
+export type * from './models/RegistryAllowance.js';
+export type * from './models/RegistryFetch.js';
+export type * from './models/RegistryVersionFact.js';
+export type * from './models/RegistryApprovedVersion.js';
+export type * from './models/RegistryPlanRefusal.js';
 export type * from './models/SchedulerLease.js';
 export type * from './models/Principal.js';
+export type * from './models/ResourceGrant.js';
 export type * from './models/Task.js';
 export type * from './models/Secret.js';
 export type * from './models/AgentSecret.js';
@@ -29,4 +36,10 @@ export type * from './models/OAuthAuthorizationRequest.js';
 export type * from './models/OAuthAuthorizationCode.js';
 export type * from './models/OAuthFamily.js';
 export type * from './models/AuthRateLimit.js';
+export type * from './models/AgentRepository.js';
+export type * from './models/RunHostCheck.js';
+export type * from './models/RunHostStatus.js';
+export type * from './models/HostEventDelivery.js';
+export type * from './models/HostIdentity.js';
+export type * from './models/HostIdentityLinkRequest.js';
 export type * from './commonInputTypes.js';

package/dist/help/build.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/help/build.js

@@ -0,0 +1,9 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { buildHelpCatalog } from "./catalog.js";
+const helpRoot = fileURLToPath(new URL("../../help/", import.meta.url));
+const output = fileURLToPath(new URL("../../dist/help-index.json", import.meta.url));
+const catalog = await buildHelpCatalog(helpRoot);
+await mkdir(dirname(output), { recursive: true });
+await writeFile(output, `${JSON.stringify(catalog, null, 2)}\n`, "utf8");

package/dist/help/catalog.d.ts

@@ -0,0 +1,24 @@
+export type HelpAudience = "operator" | "developer" | "all";
+export interface HelpHeading {
+    level: number;
+    text: string;
+    slug: string;
+}
+export interface HelpPage {
+    id: string;
+    title: string;
+    summary: string;
+    audience: HelpAudience;
+    tags: string[];
+    appliesTo: string;
+    sourcePath: string;
+    markdown: string;
+    plainText: string;
+    headings: HelpHeading[];
+}
+export interface HelpCatalog {
+    schemaVersion: 1;
+    pages: HelpPage[];
+}
+/** Builds the deterministic, release-bundled catalog from the checked-in help corpus. */
+export declare function buildHelpCatalog(root: string): Promise<HelpCatalog>;

package/dist/help/catalog.js

@@ -0,0 +1,160 @@
+import { readdir, readFile } from "node:fs/promises";
+import { relative, resolve, sep } from "node:path";
+const REQUIRED_FIELDS = ["id", "title", "summary", "audience", "tags", "appliesTo"];
+const ALLOWED_FIELDS = new Set(REQUIRED_FIELDS);
+const MARKDOWN_LINK = /!?\[[^\]]*\]\(([^)\s]+)(?:\s+[^)]*)?\)/g;
+function failure(sourcePath, message) {
+    return new Error(`Invalid help page ${sourcePath}: ${message}`);
+}
+function slugify(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/[`*_~]/g, "")
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/(^-|-$)/g, "");
+}
+function plainText(markdown) {
+    return markdown
+        .replace(/```[\s\S]*?```/g, (block) => block.replace(/```[^\n]*\n?|```/g, ""))
+        .replace(/!\[[^\]]*\]\([^)]*\)/g, "")
+        .replace(/\[([^\]]+)\]\([^)]*\)/g, "$1")
+        .replace(/^\s{0,3}#{1,6}\s+/gm, "")
+        .replace(/^\s{0,3}[-*+]\s+/gm, "")
+        .replace(/^\s{0,3}\d+\.\s+/gm, "")
+        .replace(/[>*_`]/g, "")
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function parseFrontmatter(sourcePath, markdown) {
+    const match = /^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/.exec(markdown);
+    if (!match)
+        throw failure(sourcePath, "expected YAML frontmatter delimited by ---");
+    const fields = new Map();
+    for (const line of match[1].split(/\r?\n/)) {
+        const field = /^([A-Za-z][A-Za-z0-9]*):\s*(.+)$/.exec(line);
+        if (!field)
+            throw failure(sourcePath, `unsupported frontmatter line: ${line}`);
+        const [, key, value] = field;
+        if (!ALLOWED_FIELDS.has(key))
+            throw failure(sourcePath, `unknown frontmatter field "${key}"`);
+        if (fields.has(key))
+            throw failure(sourcePath, `duplicate frontmatter field "${key}"`);
+        fields.set(key, value.trim());
+    }
+    for (const required of REQUIRED_FIELDS) {
+        if (!fields.get(required))
+            throw failure(sourcePath, `missing frontmatter field "${required}"`);
+    }
+    return { fields, body: match[2] };
+}
+function parseTags(sourcePath, value) {
+    const match = /^\[([^\]]*)\]$/.exec(value);
+    if (!match)
+        throw failure(sourcePath, "tags must be an inline list, for example [budget, security]");
+    const tags = match[1]
+        .split(",")
+        .map((tag) => tag.trim())
+        .filter(Boolean);
+    if (!tags.length)
+        throw failure(sourcePath, "tags must contain at least one value");
+    if (new Set(tags).size !== tags.length)
+        throw failure(sourcePath, "tags must not contain duplicates");
+    return tags;
+}
+function headings(markdown) {
+    return [...markdown.matchAll(/^(#{1,6})\s+(.+?)\s*#*\s*$/gm)].map((match) => ({
+        level: match[1].length,
+        text: match[2].trim(),
+        slug: slugify(match[2]),
+    }));
+}
+function parsePage(root, filePath, markdown) {
+    const sourcePath = relative(root, filePath).split(sep).join("/");
+    const { fields, body } = parseFrontmatter(sourcePath, markdown);
+    const audience = fields.get("audience");
+    if (audience !== "operator" && audience !== "developer" && audience !== "all") {
+        throw failure(sourcePath, 'audience must be "operator", "developer", or "all"');
+    }
+    const pageHeadings = headings(body);
+    return {
+        filePath,
+        page: {
+            id: fields.get("id"),
+            title: fields.get("title"),
+            summary: fields.get("summary"),
+            audience,
+            tags: parseTags(sourcePath, fields.get("tags")),
+            appliesTo: fields.get("appliesTo"),
+            sourcePath,
+            markdown: body,
+            plainText: plainText(body),
+            headings: pageHeadings,
+        },
+    };
+}
+async function markdownFiles(directory) {
+    const entries = await readdir(directory, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+        const path = resolve(directory, entry.name);
+        if (entry.isDirectory())
+            files.push(...(await markdownFiles(path)));
+        else if (entry.isFile() && entry.name.endsWith(".md"))
+            files.push(path);
+        else if (entry.isSymbolicLink())
+            throw new Error(`Help corpus must not contain symbolic links: ${path}`);
+    }
+    return files;
+}
+function isWithin(root, candidate) {
+    const path = relative(root, candidate);
+    return path === "" || (!path.startsWith(`..${sep}`) && path !== "..");
+}
+function validateLinks(root, pages) {
+    const byId = new Map(pages.map(({ page }) => [page.id, page]));
+    const byFile = new Map(pages.map((parsed) => [resolve(parsed.filePath), parsed.page]));
+    for (const { page, filePath } of pages) {
+        for (const match of page.markdown.matchAll(MARKDOWN_LINK)) {
+            const href = match[1];
+            if (href.startsWith("help://")) {
+                const id = href.slice("help://".length).split("#", 1)[0];
+                if (!byId.has(id))
+                    throw failure(page.sourcePath, `unknown help link "${href}"`);
+                continue;
+            }
+            const [target, fragment] = href.split("#", 2);
+            let linkedPage = page;
+            if (target.endsWith(".md")) {
+                const linkedPath = resolve(filePath, "..", target);
+                if (!isWithin(root, linkedPath))
+                    continue;
+                linkedPage = byFile.get(linkedPath);
+                if (!linkedPage)
+                    throw failure(page.sourcePath, `unknown help link "${href}"`);
+            }
+            else if (target) {
+                continue;
+            }
+            if (fragment && !linkedPage.headings.some((heading) => heading.slug === decodeURIComponent(fragment))) {
+                throw failure(page.sourcePath, `unknown help heading "${href}"`);
+            }
+        }
+    }
+}
+/** Builds the deterministic, release-bundled catalog from the checked-in help corpus. */
+export async function buildHelpCatalog(root) {
+    const canonicalRoot = resolve(root);
+    const files = await markdownFiles(canonicalRoot);
+    if (!files.length)
+        throw new Error(`Help corpus has no Markdown pages: ${canonicalRoot}`);
+    const pages = await Promise.all(files.map(async (filePath) => parsePage(canonicalRoot, filePath, await readFile(filePath, "utf8"))));
+    pages.sort((a, b) => a.page.id.localeCompare(b.page.id));
+    for (const [index, current] of pages.entries()) {
+        if (index > 0 && current.page.id === pages[index - 1].page.id) {
+            throw failure(current.page.sourcePath, `duplicate page id "${current.page.id}"`);
+        }
+    }
+    validateLinks(canonicalRoot, pages);
+    return { schemaVersion: 1, pages: pages.map(({ page }) => page) };
+}

package/dist/help/cli.d.ts

@@ -0,0 +1,2 @@
+/** Runs the dependency-free, bundled help command. */
+export declare function helpCommand(args: string[]): Promise<void>;

package/dist/help/cli.js

@@ -0,0 +1,65 @@
+import { loadBundledHelpCatalog } from "./runtime.js";
+import { searchHelp } from "./search.js";
+function helpUsage() {
+    return `usage:
+  wardby help list
+  wardby help search <terms>
+  wardby help open <article-id>
+
+Search is offline and fuzzy across titles, tags, headings, summaries, and article text.`;
+}
+function print(message) {
+    process.stdout.write(`${message}\n`);
+}
+function printPage(page) {
+    print(page.markdown.trim());
+}
+function printList(catalog) {
+    print(`Wardby help (${catalog.pages.length} articles)`);
+    for (const page of catalog.pages) {
+        print(`\n${page.id}\n  ${page.title} — ${page.summary}`);
+    }
+    print("\nUse `wardby help search <terms>` to find an article, then `wardby help open <article-id>` to read it.");
+}
+function printResults(catalog, query) {
+    const results = searchHelp(catalog, query);
+    if (!results.length) {
+        print(`No help articles matched "${query}".`);
+        return;
+    }
+    print(`Help results for "${query}":`);
+    for (const result of results.slice(0, 10)) {
+        print(`\n${result.page.title} (${result.page.id})`);
+        if (result.matchedHeading && result.matchedHeading.text !== result.page.title) {
+            print(`  Match: ${result.matchedHeading.text}`);
+        }
+        print(`  ${result.excerpt}`);
+    }
+}
+/** Runs the dependency-free, bundled help command. */
+export async function helpCommand(args) {
+    const catalog = await loadBundledHelpCatalog();
+    const [operation, ...rest] = args;
+    if (!operation || operation === "list") {
+        printList(catalog);
+        return;
+    }
+    if (operation === "search") {
+        const query = rest.join(" ").trim();
+        if (!query)
+            throw new Error("help search requires one or more terms.\n\n" + helpUsage());
+        printResults(catalog, query);
+        return;
+    }
+    if (operation === "open") {
+        const id = rest[0];
+        if (!id || rest.length !== 1)
+            throw new Error("help open requires exactly one article id.\n\n" + helpUsage());
+        const page = catalog.pages.find((candidate) => candidate.id === id);
+        if (!page)
+            throw new Error(`unknown help article "${id}". Run \`wardby help list\` to see available articles.`);
+        printPage(page);
+        return;
+    }
+    throw new Error(`unknown help command "${operation}".\n\n${helpUsage()}`);
+}

package/dist/help/runtime.d.ts

@@ -0,0 +1,3 @@
+import type { HelpCatalog } from "./catalog.js";
+/** Loads the immutable help catalog bundled with this Wardby release, once per process. */
+export declare function loadBundledHelpCatalog(): Promise<HelpCatalog>;

package/dist/help/runtime.js

@@ -0,0 +1,44 @@
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+const COMPILED_CATALOG = fileURLToPath(new URL("../help-index.json", import.meta.url));
+const SOURCE_CATALOG = fileURLToPath(new URL("../../dist/help-index.json", import.meta.url));
+function isPage(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const page = value;
+    return (typeof page.id === "string" &&
+        typeof page.title === "string" &&
+        typeof page.summary === "string" &&
+        typeof page.markdown === "string" &&
+        typeof page.plainText === "string" &&
+        Array.isArray(page.tags) &&
+        Array.isArray(page.headings));
+}
+function parseCatalog(serialized) {
+    const value = JSON.parse(serialized);
+    if (!value || typeof value !== "object")
+        throw new Error("bundled help catalog is not an object");
+    const catalog = value;
+    if (catalog.schemaVersion !== 1 || !Array.isArray(catalog.pages) || !catalog.pages.every(isPage)) {
+        throw new Error("bundled help catalog has an unsupported format");
+    }
+    return catalog;
+}
+async function readCatalog() {
+    for (const path of [COMPILED_CATALOG, SOURCE_CATALOG]) {
+        try {
+            return parseCatalog(await readFile(path, "utf8"));
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+    }
+    throw new Error("Wardby help is unavailable because the bundled help catalog is missing. Run `npm run build`.");
+}
+let catalog;
+/** Loads the immutable help catalog bundled with this Wardby release, once per process. */
+export function loadBundledHelpCatalog() {
+    catalog ??= readCatalog();
+    return catalog;
+}

package/dist/help/search.d.ts

@@ -0,0 +1,9 @@
+import type { HelpCatalog, HelpHeading, HelpPage } from "./catalog.js";
+export interface HelpSearchResult {
+    page: HelpPage;
+    score: number;
+    matchedHeading?: HelpHeading;
+    excerpt: string;
+}
+/** Finds pages with deterministic, offline fuzzy matching over their catalog metadata and body. */
+export declare function searchHelp(catalog: HelpCatalog, query: string): HelpSearchResult[];

package/dist/help/search.js

@@ -0,0 +1,104 @@
+const WORD = /[a-z0-9]+/g;
+function words(value) {
+    return value.toLowerCase().match(WORD) ?? [];
+}
+function damerauLevenshtein(left, right) {
+    const previousPrevious = new Array(right.length + 1).fill(0);
+    let previous = new Array(right.length + 1).fill(0);
+    let current = new Array(right.length + 1).fill(0);
+    for (let column = 0; column <= right.length; column += 1)
+        previous[column] = column;
+    for (let row = 1; row <= left.length; row += 1) {
+        current[0] = row;
+        for (let column = 1; column <= right.length; column += 1) {
+            const substitution = previous[column - 1] + Number(left[row - 1] !== right[column - 1]);
+            const insertion = current[column - 1] + 1;
+            const deletion = previous[column] + 1;
+            let distance = Math.min(substitution, insertion, deletion);
+            if (row > 1 && column > 1 && left[row - 1] === right[column - 2] && left[row - 2] === right[column - 1]) {
+                distance = Math.min(distance, previousPrevious[column - 2] + 1);
+            }
+            current[column] = distance;
+        }
+        previousPrevious.splice(0, previousPrevious.length, ...previous);
+        [previous, current] = [current, previous];
+    }
+    return previous[right.length];
+}
+function wordScore(query, candidate) {
+    if (query === candidate)
+        return 1;
+    if (query.length >= 2 && candidate.startsWith(query))
+        return 0.9;
+    if (query.length >= 3 && candidate.includes(query))
+        return 0.75;
+    // Short words are too broad for typo matching. Longer terms accept a small,
+    // bounded edit distance, including a swapped adjacent character.
+    if (query.length < 4 || candidate.length < 4)
+        return 0;
+    const maximumDistance = query.length <= 5 ? 1 : query.length <= 8 ? 2 : 3;
+    const distance = damerauLevenshtein(query, candidate);
+    if (distance > maximumDistance)
+        return 0;
+    return 0.6 - (distance - 1) * 0.1;
+}
+function fieldScore(query, field) {
+    let best = 0;
+    for (const candidate of words(field.text))
+        best = Math.max(best, wordScore(query, candidate));
+    return best * field.weight;
+}
+function pageScore(queries, page) {
+    const fields = [
+        { text: page.title, weight: 12 },
+        { text: page.tags.join(" "), weight: 10 },
+        { text: page.summary, weight: 5 },
+        ...page.headings.map((heading) => ({ text: heading.text, weight: 8 })),
+        { text: page.plainText, weight: 1 },
+    ];
+    let total = 0;
+    for (const query of queries) {
+        const score = Math.max(...fields.map((field) => fieldScore(query, field)));
+        if (score === 0)
+            return undefined;
+        total += score;
+    }
+    return total;
+}
+function matchingHeading(queries, page) {
+    return page.headings
+        .map((heading) => ({
+        heading,
+        score: queries.reduce((total, query) => total + fieldScore(query, { text: heading.text, weight: 1 }), 0),
+    }))
+        .filter((candidate) => candidate.score > 0)
+        .sort((left, right) => right.score - left.score || left.heading.slug.localeCompare(right.heading.slug))[0]?.heading;
+}
+function truncate(value, length = 180) {
+    return value.length <= length ? value : `${value.slice(0, length - 1).trimEnd()}…`;
+}
+function excerpt(queries, page) {
+    const candidates = [page.summary, ...page.plainText.split(/(?<=[.!?])\s+/)].filter(Boolean);
+    const best = candidates
+        .map((candidate) => ({
+        candidate,
+        score: queries.reduce((total, query) => total + fieldScore(query, { text: candidate, weight: 1 }), 0),
+    }))
+        .sort((left, right) => right.score - left.score || left.candidate.length - right.candidate.length)[0];
+    return truncate(best?.candidate ?? page.summary);
+}
+/** Finds pages with deterministic, offline fuzzy matching over their catalog metadata and body. */
+export function searchHelp(catalog, query) {
+    const queries = words(query);
+    if (!queries.length)
+        return [];
+    const results = [];
+    for (const page of catalog.pages) {
+        const score = pageScore(queries, page);
+        if (score === undefined)
+            continue;
+        const heading = matchingHeading(queries, page);
+        results.push({ page, score, ...(heading ? { matchedHeading: heading } : {}), excerpt: excerpt(queries, page) });
+    }
+    return results.sort((left, right) => right.score - left.score || left.page.id.localeCompare(right.page.id));
+}