eve-hub 0.6.12 → 0.6.14

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # eve-hub
 
+## 0.6.14
+
+### Patch Changes
+
+- `create_agent` takes `runsOn`: a bot is created with the sandbox of where it runs, and the hosted build no longer writes sandboxes. Hosted main can create a bot by committing it to the workspace repository; it joins with the next deployment.
+
+## 0.6.13
+
+### Patch Changes
+
+- The workspace protocol says an attached image shows as an image tile on its own, so bots stop writing `![]()` for it.
+
 ## 0.6.12
 
 ### Patch Changes

package/README.md

@@ -61,7 +61,7 @@ A deployed workspace (lib/workspace-template.mjs, staged by hosted-hub/scripts/s
 
 Releases go through Changesets, as in eve. A PR that changes the kit adds a changeset (`pnpm changeset`) and applies it (`pnpm changeset version`); when it merges, `.github/workflows/release.yml` runs `changeset publish` (no bot commits to main: its ruleset allows only PR merges): the kit's `prepack` stages the package into `dist/npm` (its `publishConfig.directory`), npm gets it, and the `eve-hub@<version>` GitHub release is created. npm auth is the repo's `NPM_TOKEN` secret (an npm automation token). The template pins the version this checkout carries.
 
-The template's main gets a Vercel Sandbox and only the kit stubs that run without the hub's machine (lib/workspace-template.mjs `DEPLOYED_KIT_FILES`; eve's own bash replaces the kit's). The template's builder also mounts eve-code (`eve/extensions/code`: `apply_patch`, `grep`, the review skills, a read-only worker) and `eve/extensions/git` (`git({})`), both with no `github` option. The bot uses `gh` and `git` from bash, whose GitHub token is the sandbox firewall's (`VERCEL_SANDBOX`), and no `gh` tool is contributed. A deployed workspace's eve is the one pin in `hosted-hub/bots/package.json`, which staging copies over the template's (an eve snapshot with both `eve/world-hub` and `eve/extensions/git`; `hosted-hub/test/stage-workspace.test.mjs` checks the staged imports resolve against it). The hub and local bots stay on the hub's eve. The published tarball (`scripts/pack.mjs`) leaves out the kit__worker extension, which mounts only on the hub's machine. The hub reaches each bot's eve channel with `Authorization: Bearer $BOT_TOKEN` (`bot-token.mjs`); the kit's calls to the hub (`registry-fetch.mjs`, at `ROSTER_REGISTRY_URL`) carry `Authorization: Bearer $HUB_TOKEN` and, since the hosted hub keeps Vercel Authentication on, `x-vercel-protection-bypass: $HUB_PROTECTION_BYPASS` (the hub project's automation bypass secret), each when set.
+The template's main gets a Vercel Sandbox and only the kit stubs that run without the hub's machine (lib/workspace-template.mjs `DEPLOYED_KIT_FILES`; eve's own bash replaces the kit's). The template's builder also mounts eve-code (`eve/extensions/code`: `apply_patch`, `grep`, the review skills, a read-only worker) and `eve/extensions/git` (`git({})`), both with no `github` option. The bot uses `gh` and `git` from bash, whose GitHub token is the sandbox firewall's (the Vercel sandbox `create_agent` writes, lib/agent-template.mjs `sandboxFile`), and no `gh` tool is contributed. A deployed workspace's eve is the one pin in `hosted-hub/bots/package.json`, which staging copies over the template's (an eve snapshot with both `eve/world-hub` and `eve/extensions/git`; `hosted-hub/test/stage-workspace.test.mjs` checks the staged imports resolve against it). The hub and local bots stay on the hub's eve. The published tarball (`scripts/pack.mjs`) leaves out the kit__worker extension, which mounts only on the hub's machine. The hub reaches each bot's eve channel with `Authorization: Bearer $BOT_TOKEN` (`bot-token.mjs`); the kit's calls to the hub (`registry-fetch.mjs`, at `ROSTER_REGISTRY_URL`) carry `Authorization: Bearer $HUB_TOKEN` and, since the hosted hub keeps Vercel Authentication on, `x-vercel-protection-bypass: $HUB_PROTECTION_BYPASS` (the hub project's automation bypass secret), each when set.
 
 ## Vercel Kit connection
 

package/memory.mjs

@@ -235,7 +235,7 @@ const warnOnce = (msg) => {
 const unreadableIds = (errors) => new Set(errors.map((e) => /(?:^|\/)memory\/(?:[^/:]+\/)*([^/:]+)\.md:/.exec(e)?.[1]).filter(Boolean));
 
 // `domains`: the bot's domains (hub.workspace.json), see the header.
-export function loadMemoryRecall(root, history = [], { warn = warnOnce, domains = [] } = {}) {
+export function loadMemoryRecall(root, history = [], { warn = warnOnce, domains = /** @type {string[]} */ ([]) } = {}) {
   const { entries, errors } = readMemory(root, { folders: domainFolders(domains) });
   for (const error of errors) warn(error);
   return memoryRecall(entries, history, { unreadable: unreadableIds(errors) });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eve-hub",
-  "version": "0.6.12",
+  "version": "0.6.14",
   "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",

package/prepare.mjs

@@ -5,9 +5,10 @@
 // - bots marked `runsOn: "local"` are the Mac runner's: their folders and
 //   roster entries leave the hosted build, after hub.manifest.json records the
 //   whole roster for the hub;
-// - each bot runs in a Vercel Sandbox (the project's OIDC token opens it and
-//   pays for model calls) with only the kit stubs that run off the hub's
-//   machine (DEPLOYED_KIT_FILES);
+// - each bot runs in the Vercel Sandbox its creation wrote (the project's OIDC
+//   token opens it and pays for model calls) with only the kit stubs that run
+//   off the hub's machine (DEPLOYED_KIT_FILES); a hosted bot whose sandbox.ts
+//   is the host's fails the build, and the build never writes a sandbox;
 // - the kit extension, host-only workers and kit stubs are dropped, the hub's
 //   workflow world is wired in (and the Vercel Kit connection, if GITHUB_PATH
 //   says "kit"), every bot gets eve's git extension, and the
@@ -33,62 +34,19 @@ import { agentRunsOn, readWorkspaceFile, removeWorkspaceAgent } from "./workspac
 // instead), the browser and the screenshot paths of attach_image/view_image,
 // the mention gate (the
 // daemon's per-process HUB_AGENT and patched model credential), the tools that
-// scaffold, remove or restart bots on the hub's disk (a deployment changes its
-// roster by commit), memory (the workspace's files), and main's schedules.
+// remove or restart bots on the hub's disk (a deployment changes its roster by
+// commit; create_agent is that commit, made by the hosted hub), memory (the workspace's files), and main's schedules.
 export const DEPLOYED_KIT_FILES = new Set([
   "channels/eve.ts",
   "skills/onboarding-profile.ts",
   "tools/onboarding_scripts.ts",
   ...["react", "show", "update_thread", "list_threads", "read_thread", "post_message"].map((t) => `tools/${t}.ts`),
-  ...["create_thread", "set_summary", "move_path", "archive_thread", "unarchive_thread", "list_agents", "agent_send", "tag_threads", "dash_update", "apply_tags"].map((t) => `tools/${t}.ts`),
+  ...["create_thread", "set_summary", "move_path", "archive_thread", "unarchive_thread", "list_agents", "agent_send", "create_agent", "tag_threads", "dash_update", "apply_tags"].map((t) => `tools/${t}.ts`),
 ]);
 
 
-const vercelSandbox = (prepare) => `import { defineSandbox } from "eve/sandbox";
-import { VercelSandbox } from "eve/sandbox/vercel";
-${prepare ? 'import { installCodeTooling } from "eve/extensions/code/sandbox";\n' : ""}
-// TEMPORARY (until the Vercel Connect GitHub connector replaces it): the
-// project's GITHUB_TOKEN is added to GitHub requests by the sandbox firewall,
-// so the token never enters the sandbox. api.github.com (gh, REST) takes
-// Bearer; github.com (git over HTTPS) takes Basic. Unset: no policy.
-const token = process.env.GITHUB_TOKEN;
-const networkPolicy = token ? { allow: {
-  "api.github.com": [{ transform: [{ headers: { authorization: "Bearer " + token } }] }],
-  "github.com": [{ transform: [{ headers: { authorization: "Basic " + Buffer.from("x-access-token:" + token).toString("base64") } }] }],
-  "*": [],
-} } : undefined;
-
-// A Vercel Sandbox, opened with the project's OIDC token.
-export const environment = VercelSandbox.environment({ networkPolicy, prepare: async (sandbox) => {${prepare}
-  const run = async (command, what) => {
-    if ((await sandbox.run({ command })).exitCode !== 0) throw new Error(what + " failed");
-  };
-  if (!token) return;
-  // eve's sandbox image is Ubuntu with git only; gh and ssh-keygen come from apt.
-  await run("sudo apt-get update -qq && sudo apt-get install -y -qq gh openssh-client", "gh and ssh installation");
-  // gh refuses to run without a login; this one is a placeholder the firewall overwrites.
-  await run("mkdir -p ~/.config/gh && printf 'github.com:\\n  user: hub\\n  oauth_token: placeholder\\n  git_protocol: https\\n' > ~/.config/gh/hosts.yml", "gh login");
-  // The org requires signed commits. Eve reuses a named template sandbox after a failed prepare, so
-  // this step starts by clearing an earlier key. A key made here, registered as a signing key on
-  // the token's user, never leaves the sandbox; commits carry that user's noreply email.
-  await run([
-    "mkdir -p ~/.ssh && rm -f ~/.ssh/signing ~/.ssh/signing.pub && ssh-keygen -q -t ed25519 -N '' -C hub-bot -f ~/.ssh/signing",
-    "gh api user/ssh_signing_keys -f title=\\\"hub bot sandbox $(date -u +%FT%TZ)\\\" -f key=\\\"$(cat ~/.ssh/signing.pub)\\\" --silent",
-    "login=$(gh api user --jq .login) && id=$(gh api user --jq .id)",
-    "git config --global user.name \\\"$login\\\" && git config --global user.email \\\"$id+$login@users.noreply.github.com\\\"",
-    "git config --global gpg.format ssh && git config --global user.signingkey ~/.ssh/signing && git config --global commit.gpgsign true",
-  ].join(" && "), "git signing setup");
-} });
-export default defineSandbox(() => environment.open());
-`;
-
-export const VERCEL_SANDBOX = vercelSandbox("");
-
-// The builder's sandbox also carries eve-code's tooling (agents/builder/agent/extensions/code/).
-export const CODE_SANDBOX = vercelSandbox("\n  await installCodeTooling(sandbox);");
-
 // eve's git extension, for every bot: it points the bot at `gh` and `git` in
-// bash, whose GitHub credential is the sandbox firewall's (VERCEL_SANDBOX above).
+// bash, whose GitHub credential is the sandbox firewall's (the Vercel sandbox lib/agent-template.mjs writes).
 // With no `github` option it brokers no credential. It only guides: its `pr`
 // skill (commit, push, draft PR) loads when a bot publishes.
 export const gitExtensionFiles = () => ({ "extensions/git/extension.ts": `import git from "eve/extensions/git";\n\nexport default git({});\n` });
@@ -193,7 +151,6 @@ export function prepareDeployment(dir) {
     if (existsSync(join(bot, "schedules/learning-review.ts"))) removeStub(bot, "schedules/learning-review.ts");
     const name = basename(dirname(bot));
     const code = CODE_BOTS.includes(name);
-    writeFileSync(join(bot, "sandbox.ts"), code ? CODE_SANDBOX : VERCEL_SANDBOX);
     for (const [stub, content] of Object.entries({ ...gitExtensionFiles(), ...(code ? codeExtensionFiles(name) : {}) })) {
       mkdirSync(dirname(join(bot, stub)), { recursive: true });
       writeFileSync(join(bot, stub), content);

package/templates/execution-context-hosted-main.md

@@ -1,4 +1,4 @@
-- **Team.** There is no `create_agent` or `remove_agent`: the roster is `hub.workspace.json`, and a deployment changes it by commit. If nobody on the team covers the work well, ask the human before going on.
+- **Team.** `create_agent` takes `runsOn` (`hosted` or `local`) and commits the new bot to the workspace repository; it joins with the next deployment, and a `local` bot then runs on the owner's Mac. There is no `remove_agent`: the roster is `hub.workspace.json`, and a deployment changes it by commit. If nobody on the team covers the work well, ask the human before going on.
 - **Restarts.** There is no `restart_agent` or `restart_hub`: you cannot restart a bot or the hub. A new deployment replaces the running bots.
 - **Memory.** Add an entry as your Memory section says, by committing the file to the workspace repository (see Changing it above). With no repository, write nothing and tell the human to link one first.
 - **Schedules.** The build removes the kit's schedules (`dash`, `compact`, `prune`), so no classifier runs, no tick posts, and nothing rewrites track summaries. What you write with `set_summary` and `dash_update` stands until you change it.

package/templates/workspace-protocol.md

@@ -88,7 +88,7 @@ renders as:
 - `---` with a blank line on both sides starts a new bubble. Without the blank line above, it makes the line before it a heading.
 - Each top-level code fence is a card with a language label and a copy icon; each table is a table card. Inline code has no copy icon, so anything the reader will paste goes in a fence. Cards wrap rather than scroll: keep command lines short.
 - A link is a gray chip with an icon and its label, so labels are short nouns (`#412`, `Feed.swift:1015`). A bare URL shows only its hostname.
-- An attached image shows as an image tile. `![]()` shows only alt text; raw HTML shows literally.
+- An attached image shows as an image tile on its own; never write `![]()` for it; raw HTML shows literally.
 - Nothing collapses, and the Mentions inbox previews only the first plain-text line of each message. So each message's first bubble is its point, in at most 2 sentences; detail follows after `---`.
 - Separate updates (started, found, done) are separate posts; `---` splits one message into bubbles.
 - Tables only for 2+ rows of short, comparable values: at most 4 columns sharing the width equally, a few words per cell. A single item, or anything that needs a reason, goes in a sentence or bullets. Shorten shas to 8 characters; keep URLs and paths in link text, not cells.

package/tools/create_agent.d.ts

@@ -2,26 +2,28 @@ declare const _default: import("eve/tools").ToolDefinition<{
     name: string;
     model: string;
     reasoning?: "high" | "low" | "medium" | "xhigh" | undefined;
+    runsOn?: "hosted" | "local" | undefined;
     role: string;
     instructions?: string | undefined;
     domains?: string[] | undefined;
     preset?: "builder" | "read-only" | undefined;
 }, {
     name: string;
-    port: number;
+    port?: number;
     status: string;
 }> & {
     execute(input: {
         name: string;
         model: string;
         reasoning?: "high" | "low" | "medium" | "xhigh" | undefined;
+        runsOn?: "hosted" | "local" | undefined;
         role: string;
         instructions?: string | undefined;
         domains?: string[] | undefined;
         preset?: "builder" | "read-only" | undefined;
     }, ctx: import("eve/tools").ToolContext): Promise<{
         name: string;
-        port: number;
+        port?: number;
         status: string;
     }>;
 };

package/tools/create_agent.js

@@ -4,11 +4,12 @@ import { registryFetch } from "../registry-fetch.mjs";
 // Adds a named bot to the workspace: scaffolds agents/<name>/, registers it,
 // starts it, and opens its DM. Returns once the bot is healthy.
 export default defineTool({
-    description: "Create a new named bot in the workspace. It joins the team immediately and can be @-mentioned once this returns. Models are AI Gateway ids, e.g. openai/gpt-6-luna, anthropic/claude-opus-5.5.",
+    description: "Create a new named bot in the workspace. In a local workspace it joins the team immediately and can be @-mentioned once this returns. In a hosted workspace this commits the bot to the workspace repo, and it joins with the next deployment, hosted or on the Mac alike. Models are AI Gateway ids, e.g. openai/gpt-6-luna, anthropic/claude-opus-5.5.",
     inputSchema: z.object({
         name: z.string().regex(/^[a-z][a-z0-9-]{1,30}$/).describe("Lowercase handle, e.g. deep-diver."),
         model: z.string().describe("AI Gateway model id."),
         reasoning: z.enum(["low", "medium", "high", "xhigh"]).optional(),
+        runsOn: z.enum(["hosted", "local"]).optional().describe("Where the bot runs, fixed for its life: hosted (the Vercel bots project) or local (the human's Mac). Required in a hosted workspace; a local workspace's bots are local."),
         role: z.string().describe("One line: what this bot does."),
         instructions: z.string().optional().describe("Extra guidance: specialty, style, who it hands off to."),
         domains: z.array(z.string().regex(/^[a-z][a-z0-9-]*(\/[a-z][a-z0-9-]*)*$/)).optional().describe("Memory domains: folders under memory/ whose standing decisions this bot also recalls, e.g. [\"ui\"]. It always recalls memory/ itself."),