@kybernesis/create 0.7.10 → 0.7.13

package/dist/deploy.js

@@ -1,7 +1,8 @@
 import { execFileSync, spawnSync } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
-import { bold, dim, green, red, yellow } from "./util.js";
+import { upsertEnv } from "./envfile.js";
+import { ask, bold, dim, green, red, yellow } from "./util.js";
 /**
  * `kyb deploy` — put this repo on its host and restart it, with proof.
  *
@@ -42,6 +43,59 @@ function sshTarget(dir, explicit) {
         return `${e.EXE_VM_NAME}.exe.xyz`;
     return null;
 }
+/**
+ * Make sure EXE_MODEL names a model the integration actually serves.
+ *
+ * `kyb init` leaves it empty on purpose: the valid ids come from the host's
+ * integration, and the laptop cannot see them — `llm.int.exe.xyz` resolves only
+ * from an attached VM. But nothing then asked again, so a deployment could
+ * complete, report healthy, and fail on the first message with an error that
+ * never mentions the empty value.
+ *
+ * The host CAN see the catalog, and this command is already talking to it. So
+ * ask it, and offer the ids. Two details worth keeping: the id must carry its
+ * provider prefix (`openai/…`), and an unknown id answers `404 unsupported
+ * endpoint: /v1/responses` — an error about the endpoint, for a problem with
+ * the model.
+ */
+async function ensureModel(dir, target) {
+    if (env(dir).EXE_MODEL)
+        return;
+    console.log(yellow("  EXE_MODEL is empty — the agent has no model to run."));
+    console.log(dim("  Asking the host which models its integration serves …"));
+    let ids = [];
+    try {
+        const raw = execFileSync("ssh", [target, "curl -s --max-time 15 https://llm.int.exe.xyz/models.json || true"], { encoding: "utf8" });
+        const catalog = JSON.parse(raw);
+        // The live catalog is `{ schema_version, models: [...] }`. `data` and a bare
+        // array are accepted too rather than assuming one shape forever.
+        const entries = Array.isArray(catalog) ? catalog : (catalog.models ?? catalog.data ?? []);
+        ids = entries
+            .map((m) => m?.id)
+            .filter((id) => typeof id === "string" && id.includes("/"))
+            .sort();
+    }
+    catch {
+        ids = [];
+    }
+    if (ids.length === 0) {
+        console.log(red("\n  Could not read the model catalog from the host."));
+        console.log(dim(`  Check the integration is attached (ssh exe.dev integrations list), then run on the host:\n` +
+            `    ssh ${target} 'curl -s https://llm.int.exe.xyz/models.json'\n` +
+            `  Set EXE_MODEL to an id WITH its provider prefix, e.g. openai/gpt-5.6-sol.\n`));
+        process.exit(1);
+    }
+    console.log(dim("\n  Models this host can serve:"));
+    ids.forEach((id, i) => console.log(`    ${i + 1}. ${id}`));
+    const answer = await ask(`\n  EXE_MODEL (number or full id)?`, ids[0]);
+    const chosen = /^\d+$/.test(answer.trim()) ? ids[Number(answer.trim()) - 1] : answer.trim();
+    if (!chosen) {
+        console.log(red("  No model chosen — stopping before deploying an agent that cannot answer."));
+        process.exit(1);
+    }
+    upsertEnv(dir, { EXE_MODEL: chosen });
+    console.log(green(`  ✓ EXE_MODEL="${chosen}" written to .env.local\n`));
+}
 export async function deploy(options) {
     const dir = options.dir ?? process.cwd();
     if (!existsSync(join(dir, "agent"))) {
@@ -66,6 +120,7 @@ export async function deploy(options) {
     const name = JSON.parse(readFileSync(join(dir, "package.json"), "utf8")).name ?? "agent";
     const remote = `~/${name}`;
     console.log(dim(`  host: ${target}   path: ${remote}\n`));
+    await ensureModel(dir, target);
     const run = (cmd, args) => {
         const r = spawnSync(cmd, args, { cwd: dir, stdio: "inherit" });
         return (r.status ?? 1) === 0;
@@ -190,15 +245,47 @@ export async function deploy(options) {
         "echo started",
     ].join("\n");
     run("ssh", [target, `cd ${remote}\n${remoteScript}`]);
-    console.log(dim("\n  Waiting for the restart to report …"));
+    /**
+     * Wait on PROGRESS, not on a clock.
+     *
+     * A restart takes seconds, so this used to poll for 200s and then declare
+     * failure. A FIRST deploy is not a restart: it installs node_modules and
+     * builds from cold, which routinely runs longer than that. The deploy would
+     * report "did not report health" and exit non-zero while the build was still
+     * running perfectly well — and the honest reading of that message is that the
+     * thing is broken, so the next move is usually to kill it and start over.
+     *
+     * So: give up only when the host goes QUIET (nothing new in the log for a few
+     * minutes), and echo each new line meanwhile, because a long wait with
+     * visible progress is a different experience from a long wait in silence.
+     */
+    console.log(dim("\n  Waiting for the restart to report (first deploys build from cold) …"));
+    const QUIET_LIMIT_MS = 4 * 60_000;
+    const CEILING_MS = 30 * 60_000;
+    const startedAt = Date.now();
     let last = "";
-    for (let i = 0; i < 40; i++) {
-        const out = execFileSync("ssh", [target, `tail -6 /tmp/kyb-deploy.log 2>/dev/null || true`], {
+    let seen = "";
+    let lastChange = Date.now();
+    while (Date.now() - startedAt < CEILING_MS) {
+        const out = execFileSync("ssh", [target, `tail -40 /tmp/kyb-deploy.log 2>/dev/null || true`], {
             encoding: "utf8",
         });
         last = out;
+        if (out !== seen) {
+            for (const line of out.split("\n")) {
+                if (line && !seen.includes(line) && /npm|install|build|SOURCE IS NEWER|waiting|pid=|health:|FAILED/i.test(line)) {
+                    console.log(dim(`    ${line.trim().slice(0, 120)}`));
+                }
+            }
+            seen = out;
+            lastChange = Date.now();
+        }
         if (/health:|FAILED/.test(out))
             break;
+        if (Date.now() - lastChange > QUIET_LIMIT_MS) {
+            console.log(yellow(`\n  ! nothing new on the host for ${Math.round(QUIET_LIMIT_MS / 60_000)} minutes — giving up on the wait`));
+            break;
+        }
         await new Promise((r) => setTimeout(r, 5000));
     }
     const healthy = /health:\s*200/.test(last);
@@ -209,7 +296,8 @@ export async function deploy(options) {
         .join("\n"));
     console.log(healthy
         ? green("\n  ✓ deployed and serving the current build")
-        : yellow("\n  ! the restart did not report health — check /tmp/kyb-deploy.log on the host"));
+        : yellow("\n  ! the restart did not report health. It may still be building — this stops watching, it does not stop the host.\n" +
+            `    Watch it:  ssh ${target} 'tail -f /tmp/kyb-deploy.log'`));
     if (!healthy)
         process.exitCode = 1;
 }

package/dist/doctor.js

@@ -26,12 +26,30 @@ export async function doctor() {
     }
     const pkg = JSON.parse(readFileSync(join(cwd, "package.json"), "utf8"));
     const deps = { ...pkg.dependencies, ...pkg.devDependencies };
-    for (const p of ["@kybernesis/arcana", "@kybernesis/enterprise", "@kybernesis/multiplayer", "@kybernesis/evals"]) {
+    for (const p of ["@kybernesis/arcana", "@kybernesis/enterprise", "@kybernesis/evals"]) {
         if (deps[p])
             add("pass", `${p} ${deps[p]}`);
         else
             add("warn", `${p} not installed`, `eve add @kybernesis/${p.split("/")[1]}`);
     }
+    /**
+     * multiplayer is conversation mechanics for a SHARED channel — threads with
+     * per-speaker identity, the public/DM split. An agent reached only through
+     * Studio or a direct API has no such channel, so telling its operator to
+     * install it is advice that cannot be usefully acted on. A warning nobody can
+     * clear is how a checklist stops being read.
+     */
+    const channelsDir = join(cwd, "agent", "channels");
+    const sharedChannel = existsSync(channelsDir) && readdirSync(channelsDir).some((f) => /^(slack|discord|telegram)\./.test(f));
+    if (deps["@kybernesis/multiplayer"]) {
+        add("pass", `@kybernesis/multiplayer ${deps["@kybernesis/multiplayer"]}`);
+    }
+    else if (sharedChannel) {
+        add("warn", "@kybernesis/multiplayer not installed", "this agent has a shared channel, which needs its thread + per-speaker identity mechanics");
+    }
+    else {
+        add("pass", "no shared channel, so multiplayer is not needed");
+    }
     // ── env ────────────────────────────────────────────────────────────────
     const envPath = join(cwd, ".env.local");
     const env = {
@@ -214,10 +232,24 @@ export async function doctor() {
         else {
             add("pass", "no Vercel Connect dependencies (correct for a self-hosted agent)");
         }
-        // eve start does not read .env.local the way eve dev does.
-        add("warn", "self-hosted: export .env.local into the server process", "eve start does NOT read it; use the supervision script from @kybernesis/exe (scripts/eve-server.sh)");
-        // Prewarm runs in the eve CLI, not the built server.
-        add("warn", "self-hosted: start via `npx eve start`, not `node .output/server/index.mjs`", "sandbox templates are prewarmed by the CLI; starting the server directly skips prewarm and every sandbox tool fails with SandboxTemplateNotProvisionedError");
+        /**
+         * Both of the next two are real ways a self-hosted agent boots broken:
+         * `eve start` does not read .env.local the way `eve dev` does, and sandbox
+         * templates are prewarmed by the CLI, so launching the built server
+         * directly fails every sandbox tool with SandboxTemplateNotProvisionedError.
+         *
+         * The supervision script does both correctly. When it is present, saying so
+         * is the useful report — repeating the hazard as a warning teaches the
+         * operator that warnings here are decoration.
+         */
+        const supervisor = join(cwd, "scripts/eve-server.sh");
+        if (existsSync(supervisor)) {
+            add("pass", "scripts/eve-server.sh present (exports .env.local, starts via the eve CLI)");
+        }
+        else {
+            add("warn", "self-hosted: export .env.local into the server process", "eve start does NOT read it; use the supervision script from @kybernesis/exe (scripts/eve-server.sh)");
+            add("warn", "self-hosted: start via `npx eve start`, not `node .output/server/index.mjs`", "sandbox templates are prewarmed by the CLI; starting the server directly skips prewarm and every sandbox tool fails with SandboxTemplateNotProvisionedError");
+        }
         // The exe VM sandbox backend needs a credential that cannot be scoped.
         // Surface the blast radius here, where it is still cheap to change course.
         const sandboxFile = join(cwd, "agent/sandbox/sandbox.ts");
@@ -267,7 +299,18 @@ export async function doctor() {
         else {
             add("fail", "management routes have no KYBERNESIS_AGENT", "KYBER Studio cannot install or write routines here: the agent cannot check a grant for a name it does not know");
         }
-        add("warn", "management routes need a writable working copy", "installing edits this repo and rebuilds; on a read-only serverless bundle the routes refuse. Set restartCommand in agent/channels/kyb.ts or an install will not take effect");
+        // Installing edits the repo and rebuilds, so it only takes effect where a
+        // restart can be triggered. With restartCommand set, that is answered; the
+        // remaining requirement (a writable working copy) is a property of the
+        // host, and on a read-only bundle the routes refuse with that reason.
+        const manageFile = join(cwd, "agent/channels/kyb.ts");
+        const restartWired = existsSync(manageFile) && /^\s*restartCommand\s*:/m.test(readFileSync(manageFile, "utf8"));
+        if (restartWired) {
+            add("pass", "management routes can restart the agent after an install");
+        }
+        else {
+            add("warn", "management routes have no restartCommand", "installing edits this repo and rebuilds; without a restart the response says a restart is still required. Set restartCommand in agent/channels/kyb.ts (self-hosted: \"bash scripts/eve-server.sh restart\")");
+        }
     }
     // ── engineer subagent (build capability scoped to a subagent) ──────────
     const builderDir = join(cwd, "agent/subagents/builder");

package/dist/init.js

@@ -194,6 +194,26 @@ export async function init(rawName, options = {}) {
         catch {
             console.log(yellow("  ! could not install scripts/eve-server.sh — copy it from node_modules/@kybernesis/exe/scripts/"));
         }
+        /**
+         * Point the management routes at that script.
+         *
+         * The registry template ships `restartCommand` commented out next to an
+         * example path, because on Vercel there is nothing to restart. On a VM
+         * there is, and the correct value is not a guess — it is the script three
+         * lines above. Left commented, every install through Studio succeeds and
+         * then reports that a restart is still required, which reads as a broken
+         * feature rather than one line of config nobody was asked for.
+         */
+        const manageChannelFile = join(dir, "agent/channels/kyb.ts");
+        if (existsSync(manageChannelFile)) {
+            const appRoot = `/home/exedev/${name}`;
+            const wired = readFileSync(manageChannelFile, "utf8").replace(/export default manageChannel\(\{[\s\S]*?\}\);/, () => `export default manageChannel({\n` +
+                `  appRoot: process.env.EVE_APP_DIR ?? ${JSON.stringify(appRoot)},\n` +
+                `  restartCommand: "bash scripts/eve-server.sh restart",\n` +
+                `});`);
+            writeFileSync(manageChannelFile, wired);
+            console.log(dim("     agent/channels/kyb.ts — restart wired to that script"));
+        }
     }
     if (plan.file) {
         console.log(bold(`\n4/6  Channel: ${channel} …`));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kybernesis/create",
-  "version": "0.7.10",
+  "version": "0.7.13",
   "description": "The Kybernesis agent scaffolder and FDE toolkit: one command to a governed, remembering, multiplayer, self-testing eve agent — plus doctor and upgrade.",
   "license": "Apache-2.0",
   "type": "module",