eve-hub 0.16.11 → 0.16.12

package/kit-change.d.mts

@@ -0,0 +1,3 @@
+export type KitUpdate = { files: Record<string, string>; deletions: string[]; reported: string[] };
+export declare class KitChangeError extends Error {}
+export declare function kitChange(source: { paths: string[]; read: (paths: string[]) => Promise<Map<string, string>> }): Promise<KitUpdate>;

package/kit-change.mjs

@@ -0,0 +1,66 @@
+// What a kit update changes in a workspace repo, read from any source of its files: the hosted hub reads them over
+// GitHub's API (hosted-hub/src/onboard/repo-bump.ts), `eve-hub update` (update.mjs) from a checkout. syncKit's kit-file
+// changes, the `eve-hub/world` line dropped from each `agent.ts`, and each hosted bot's `sandbox.ts` moved to one
+// `git__gh` runs in (migrateSandbox). Customized files are left alone and reported.
+import { isKitFile, syncKit } from "./sync-kit.mjs";
+import { migrateSandbox } from "./sandbox-migrate.mjs";
+import { agentRunsOn, parseWorkspace, WorkspaceError, WORKSPACE_FILE } from "./workspace.mjs";
+import KIT_MODULES from "./kit-modules.json" with { type: "json" };
+
+const AGENT_FILE = /^agents\/([^/]+)\/agent\/(.+)$/;
+
+// The line workspaces made before kit 0.13.0 have in `agent.ts`. The kit no longer exports `eve-hub/world`, so a build that keeps it fails.
+const HUB_WORLD_LINE = /^[ \t]*experimental:\s*\{\s*workflow:\s*\{\s*world:\s*(["'])eve-hub\/world\1\s*\}\s*\},?[ \t]*\r?\n/m;
+
+// A repo a person must repair before the kit can update it; the message says what to fix.
+export class KitChangeError extends Error {}
+
+// `paths` are every file in the repo, workspace-relative; `read(paths)` returns their text by path.
+export async function kitChange({ paths, read }) {
+  if (!paths.includes(WORKSPACE_FILE)) throw new KitChangeError(`no ${WORKSPACE_FILE}`);
+  const definition = definitionOf((await read([WORKSPACE_FILE])).get(WORKSPACE_FILE));
+  const isAgentFile = (path) => /(?:^|\/)agent\.ts$/.test(AGENT_FILE.exec(path)?.[2] ?? "");
+  const hostedSandbox = (path) => {
+    const m = AGENT_FILE.exec(path);
+    return m?.[2] === "sandbox.ts" && definition.agents.some((a) => a.name === m[1]) && agentRunsOn(definition, m[1]) === "hosted";
+  };
+  const found = paths.filter((p) => isKitFile(AGENT_FILE.exec(p)?.[2] ?? "") || isAgentFile(p) || hostedSandbox(p));
+  const text = await read(found);
+  const files = new Map(definition.agents.map((a) => [a.name, {}]));
+  const agentFiles = [], sandboxes = [];
+  for (const p of found) {
+    const [, bot, file] = AGENT_FILE.exec(p);
+    if (!files.has(bot)) continue;
+    if (isAgentFile(p)) agentFiles.push({ path: p, text: text.get(p) });
+    if (hostedSandbox(p)) sandboxes.push({ path: p, text: text.get(p) });
+    else if (isKitFile(file)) files.get(bot)[file] = text.get(p);
+  }
+  const tiersOf = (name) => Object.keys(definition.agents.find((a) => a.name === name)?.subagents ?? {});
+  const bots = [...files].map(([name, f]) => ({ name, runsOn: agentRunsOn(definition, name), files: f, subagents: tiersOf(name) }));
+  const change = syncKit({ bots, modules: KIT_MODULES });
+  const path = (bot, file) => `agents/${bot}/agent/${file}`;
+  const world = agentFiles.filter((f) => f.text.includes("eve-hub/world")).map((f) => ({ path: f.path, text: f.text.replace(HUB_WORLD_LINE, "") }));
+  const moved = sandboxes.map((f) => ({ path: f.path, text: f.text, ...migrateSandbox(f.text) }));
+  return {
+    files: {
+      ...Object.fromEntries(change.write.map((w) => [path(w.bot, w.file), w.content])),
+      ...Object.fromEntries(world.filter((f) => !f.text.includes("eve-hub/world")).map((f) => [f.path, f.text])),
+      ...Object.fromEntries(moved.filter((f) => f.source !== undefined && f.source !== f.text).map((f) => [f.path, f.source])),
+    },
+    deletions: change.delete.map((d) => path(d.bot, d.file)),
+    reported: [
+      ...change.report.map((r) => `${path(r.bot, r.file)} ${r.reason}`),
+      ...world.filter((f) => f.text.includes("eve-hub/world")).map((f) => `${f.path} still imports eve-hub/world, which the kit no longer has`),
+      ...moved.filter((f) => f.reason).map((f) => `${f.path} ${f.reason}`),
+    ],
+  };
+}
+
+function definitionOf(text) {
+  let json;
+  try { json = JSON.parse(text); } catch { throw new KitChangeError(`${WORKSPACE_FILE} is not valid JSON; fix it, then retry`); }
+  try { return parseWorkspace(json); } catch (e) {
+    if (e instanceof WorkspaceError) throw new KitChangeError(`${e.message}; fix it, then retry`);
+    throw e;
+  }
+}

package/kit-store.d.mts

@@ -0,0 +1,6 @@
+export declare const KIT_STORE: string;
+export declare const KIT_LATEST: string;
+export declare function kitTarball(version: string): string;
+export declare function kitTarballUrl(version: string): string;
+export declare function kitLatestUrl(): string;
+export declare function pinnedVersion(pin: string | undefined): string | undefined;

package/kit-store.mjs

@@ -0,0 +1,14 @@
+// Where each eve-hub version's tarball is served: a public Vercel Blob store (eve-hub-kit, on vercel-internal-playground),
+// one immutable file per version, uploaded by scripts/publish.mjs before the npm publish. Hosted workspaces pin this URL,
+// so nothing a deploy waits on reads eve-hub from npm, whose publish-time malware scan can hold a new version 15 minutes or more.
+// `latest.json` beside them names the newest release; a workspace's eve-hub-update workflow reads it.
+export const KIT_STORE = "https://fql3r3ljskj7rzcd.public.blob.vercel-storage.com";
+export const kitTarball = (version) => `eve-hub/eve-hub-${version}.tgz`;
+export const kitTarballUrl = (version) => `${KIT_STORE}/${kitTarball(version)}`;
+export const KIT_LATEST = "eve-hub/latest.json";
+export const kitLatestUrl = () => `${KIT_STORE}/${KIT_LATEST}`;
+
+// The version a pin names: a tarball URL from the store or a plain version; undefined for anything else (a link, a range).
+export function pinnedVersion(pin) {
+  return /(?:^|\/eve-hub-)(\d+\.\d+\.\d+)(?:\.tgz)?$/.exec(pin ?? "")?.[1];
+}

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "eve-hub",
-  "version": "0.16.11",
+  "version": "0.16.12",
   "license": "Apache-2.0",
   "description": "Bot-side code shared by every hub agent: registry tools, the roster hook, the eve channel, the host sandbox and browser, and model helpers.",
   "type": "module",
+  "bin": {
+    "eve-hub": "./update.mjs"
+  },
   "exports": {
     "./package.json": "./package.json",
     "./tools/*": "./tools/*.js",
@@ -30,7 +33,10 @@
     "./bot-token": "./bot-token.mjs",
     "./hub-oidc": "./hub-oidc.mjs",
     "./prepare": "./prepare.mjs",
-    "./vercel": "./vercel.mjs"
+    "./vercel": "./vercel.mjs",
+    "./kit-change": "./kit-change.mjs",
+    "./kit-store": "./kit-store.mjs",
+    "./update": "./update.mjs"
   },
   "peerDependencies": {
     "@vercel/connect": "^2.4.1",
@@ -47,5 +53,8 @@
     "smol-toml": "^1.9.1",
     "tree-sitter-bash": "0.25.1",
     "web-tree-sitter": "0.27.1"
+  },
+  "hubPins": {
+    "eve": "0.88.0"
   }
 }

package/update.d.mts

@@ -0,0 +1,4 @@
+export type UpdateResult = { version: string; from: string | null; current: boolean; changed: string[]; deleted: string[]; left: { path: string; reason: string }[] };
+export declare function update(options?: { dir?: string; version?: string; eve?: string }): Promise<UpdateResult>;
+export declare function summary(result: UpdateResult): string;
+export declare function commitRequest(result: UpdateResult, at: { dir?: string; repo: string; branch: string; head: string }): unknown;

package/update.mjs

@@ -0,0 +1,82 @@
+#!/usr/bin/env node
+// `eve-hub update`, run in a workspace checkout by its eve-hub-update workflow (hosted-hub/lib/workspace-template.mjs)
+// as `npx --yes <this version's tarball URL> update`: moves the repo to this kit. It applies kitChange (kit-change.mjs)
+// to the files on disk and pins `eve-hub` to this version's tarball, and `eve` to the hub's (`hubPins.eve`, stamped by
+// scripts/pack.mjs). Customized files stay as they are and are reported. A repo already on this version is left alone.
+// `--json` prints the result; `--summary <file>` appends what changed (summary); `--commit <file> --repo <o/n>` writes
+// the GitHub request that commits the update onto the checkout's branch (commitRequest).
+import { execFileSync } from "node:child_process";
+import { appendFileSync, readdirSync, readFileSync, rmSync, mkdirSync, writeFileSync } from "node:fs";
+import { dirname, join, relative } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { kitChange, KitChangeError } from "./kit-change.mjs";
+import { kitTarballUrl, pinnedVersion } from "./kit-store.mjs";
+
+const SKIPPED = new Set([".git", "node_modules", ".eve", ".vercel", ".hub"]);
+const OWN = JSON.parse(readFileSync(join(dirname(fileURLToPath(import.meta.url)), "package.json"), "utf8"));
+
+function filesIn(root, dir = root) {
+  return readdirSync(dir, { withFileTypes: true }).flatMap((e) => SKIPPED.has(e.name) ? []
+    : e.isDirectory() ? filesIn(root, join(dir, e.name))
+    : e.isFile() ? [relative(root, join(dir, e.name)).split("\\").join("/")] : []);
+}
+
+export async function update({ dir = process.cwd(), version = OWN.version, eve = OWN.hubPins?.eve } = {}) {
+  const pkgFile = join(dir, "package.json");
+  const pkg = JSON.parse(readFileSync(pkgFile, "utf8"));
+  const pin = kitTarballUrl(version);
+  const current = pkg.dependencies?.["eve-hub"];
+  const from = pinnedVersion(current);
+  const result = { version, from: from ?? current ?? null, changed: [], deleted: [], left: [] };
+  if (current === pin) return { ...result, current: true };
+  const change = await kitChange({ paths: filesIn(dir), read: async (paths) => new Map(paths.map((p) => [p, readFileSync(join(dir, p), "utf8")])) });
+  for (const [path, text] of Object.entries(change.files)) {
+    mkdirSync(dirname(join(dir, path)), { recursive: true });
+    writeFileSync(join(dir, path), text);
+  }
+  for (const path of change.deletions) rmSync(join(dir, path), { force: true });
+  writeFileSync(pkgFile, `${JSON.stringify({ ...pkg, dependencies: { ...pkg.dependencies, "eve-hub": pin, ...(eve === undefined ? {} : { eve }) } }, null, 2)}\n`);
+  const left = change.reported.map((r) => { const i = r.indexOf(" "); return { path: r.slice(0, i), reason: r.slice(i + 1) }; });
+  return { ...result, current: false, changed: ["package.json", ...Object.keys(change.files)].sort(), deleted: change.deletions.sort(), left };
+}
+
+export function summary(r) {
+  const list = (items) => items.map((i) => `- \`${i}\``).join("\n");
+  return [
+    `Moves this workspace from eve-hub ${r.from ?? "(unpinned)"} to ${r.version}.`,
+    r.changed.length ? `\nChanged:\n${list(r.changed)}` : "",
+    r.deleted.length ? `\nDeleted:\n${list(r.deleted)}` : "",
+    r.left.length ? `\nKept as you customized them, so this release's version of them is not applied:\n${r.left.map((l) => `- \`${l.path}\` ${l.reason}`).join("\n")}` : "",
+  ].join("\n").trim() + "\n";
+}
+
+// The GraphQL `createCommitOnBranch` request that commits the update onto `branch` if it is still at `head`. GitHub creates
+// and signs that commit, so a repo whose rules require signed commits takes it; a commit made in the checkout and pushed is unsigned.
+export function commitRequest(r, { dir = process.cwd(), repo, branch, head }) {
+  return {
+    query: "mutation($input: CreateCommitOnBranchInput!) { createCommitOnBranch(input: $input) { commit { url } } }",
+    variables: { input: { branch: { repositoryNameWithOwner: repo, branchName: branch }, expectedHeadOid: head, message: { headline: `eve-hub@${r.version}`, body: summary(r) },
+      fileChanges: { additions: r.changed.map((path) => ({ path, contents: readFileSync(join(dir, path)).toString("base64") })), deletions: r.deleted.map((path) => ({ path })) } } },
+  };
+}
+
+if (process.argv[1] && fileURLToPath(import.meta.url) === (await import("node:fs")).realpathSync(process.argv[1])) {
+  const [command, ...args] = process.argv.slice(2);
+  const arg = (name) => { const i = args.indexOf(name); return i >= 0 ? args[i + 1] : undefined; };
+  if (command !== "update" || (arg("--commit") !== undefined && !arg("--repo"))) { console.error("usage: eve-hub update [--json] [--summary <file>] [--commit <file> --repo <owner/name>]"); process.exit(2); }
+  try {
+    const r = await update();
+    if (arg("--summary")) appendFileSync(arg("--summary"), summary(r));
+    if (arg("--commit") && !r.current) {
+      const git = (...a) => execFileSync("git", a, { encoding: "utf8" }).trim();
+      writeFileSync(arg("--commit"), JSON.stringify(commitRequest(r, { repo: arg("--repo"), branch: git("branch", "--show-current"), head: git("rev-parse", "HEAD") })));
+    }
+    if (args.includes("--json")) console.log(JSON.stringify(r));
+    else console.log(r.current ? `already on eve-hub ${r.version}` : `eve-hub ${r.from} -> ${r.version}: ${r.changed.length + r.deleted.length} files changed, ${r.left.length} kept as customized`);
+  } catch (e) {
+    if (!(e instanceof KitChangeError)) throw e;
+    console.error(e.message);
+    process.exit(1);
+  }
+}