@kybernesis/create 0.9.0 → 0.11.0

package/dist/cli.js

@@ -19,6 +19,7 @@ import { bold, dim, red } from "./util.js";
 import { init } from "./init.js";
 import { doctor } from "./doctor.js";
 import { upgrade } from "./upgrade.js";
+import { tui } from "./tui.js";
 import { installSkills } from "./skills.js";
 import { deploy } from "./deploy.js";
 import { register } from "./register.js";
@@ -70,6 +71,7 @@ const COMMANDS = {
     register: "Register this agent with the control plane (--name, --url).",
     deploy: "Deploy this agent to its host (--no-env to leave the env file alone).",
     upgrade: "Bring @kybernesis packages and eve to the certified versions (--skip-eval).",
+    tui: "Talk to your agents in the terminal.",
     version: "Print the version of this tool.",
 };
 /**
@@ -132,6 +134,9 @@ switch (command) {
     case "deploy":
         await deploy({ host: flag(rest, "host"), noEnv: rest.includes("--no-env") });
         break;
+    case "tui":
+        tui(rest);
+        break;
     case "upgrade":
         await upgrade(rest.includes("--skip-eval"));
         break;

package/dist/doctor.js

@@ -250,6 +250,31 @@ export async function doctor() {
             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");
         }
+        /**
+         * A self-hosted agent answering everything twice.
+         *
+         * The local queue delivers a turn by POSTing it to this same server and
+         * holds that connection open for the whole turn, but its client gives up
+         * after 30 seconds by default. Every turn slower than that is redelivered,
+         * and the workflow re-executes steps that already ran — so the person gets
+         * two differently-worded answers to one question, and the log says only
+         * that a retry recovered. It is reported as the model being odd, which
+         * sends the search nowhere near the transport.
+         *
+         * Hosted agents never see it; real queue infrastructure runs there. This is
+         * a cost of self-hosting that nothing in the environment announces.
+         */
+        const QUEUE_TIMEOUT_FLOOR_MS = 120_000;
+        const shortQueueTimeouts = [
+            "WORKFLOW_LOCAL_HEADERS_TIMEOUT_MS",
+            "WORKFLOW_LOCAL_BODY_TIMEOUT_MS",
+        ].filter((name) => Number(env[name] ?? 30_000) < QUEUE_TIMEOUT_FLOOR_MS);
+        if (shortQueueTimeouts.length === 0) {
+            add("pass", "local queue delivery survives turns longer than 30s");
+        }
+        else {
+            add("fail", `self-hosted: ${shortQueueTimeouts.join(" and ")} left at the 30s default`, "one queue delivery holds a connection open for the entire turn, so any turn slower than the timeout is redelivered and its steps re-run — the agent answers the same question twice, with two different answers, and nothing reports an error. Set both to 900000 in .env.local and restart the server");
+        }
         // 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");

package/dist/init.js

@@ -166,6 +166,21 @@ export async function init(rawName, options = {}) {
          * curl https://llm.int.exe.xyz/models.json
          */
         known.EXE_MODEL = "";
+        /**
+         * Longer than any turn, because the alternative is answering twice.
+         *
+         * The local queue delivers a turn by POSTing it to this same server and
+         * holds the connection open until the turn finishes, but its client gives
+         * up after 30 seconds by default. Any turn slower than that is redelivered
+         * and its steps re-run, so the person gets two differently-worded answers
+         * to one question with nothing in any log that looks like a fault.
+         *
+         * Written at scaffold rather than documented: it only affects self-hosted
+         * agents, it has one sensible value, and the failure it prevents is one
+         * nobody recognises in time.
+         */
+        known.WORKFLOW_LOCAL_HEADERS_TIMEOUT_MS = "900000";
+        known.WORKFLOW_LOCAL_BODY_TIMEOUT_MS = "900000";
     }
     upsertEnv(dir, known);
     if (!options.yes)

package/dist/tui.d.ts

@@ -0,0 +1 @@
+export declare function tui(args: string[]): void;

package/dist/tui.js

@@ -0,0 +1,48 @@
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import { delimiter, join } from "node:path";
+import { bold, dim, yellow } from "./util.js";
+/**
+ * Hand the terminal to the TUI.
+ *
+ * @remarks
+ * The TUI is a compiled binary rather than part of this package, so this
+ * command's whole job is finding it and getting out of the way. `stdio:
+ * "inherit"` is the load-bearing part: a full-screen app needs the real
+ * terminal, not a pipe, and anything that buffers its output turns it into
+ * garbage on the way through.
+ *
+ * The search order is deliberate. PATH first, so a version someone installed
+ * on purpose wins; then the two places it actually lands — cargo's bin, and a
+ * checkout's release build — because "command not found" is a useless answer
+ * when the binary is sitting in one of two well-known directories.
+ */
+const BINARY = "kyb-tui";
+function candidates() {
+    const onPath = (process.env.PATH ?? "")
+        .split(delimiter)
+        .filter(Boolean)
+        .map((dir) => join(dir, BINARY));
+    return [
+        ...onPath,
+        join(homedir(), ".cargo", "bin", BINARY),
+        join(homedir(), "kyb-tui", "target", "release", BINARY),
+    ];
+}
+export function tui(args) {
+    const binary = candidates().find((path) => existsSync(path));
+    if (!binary) {
+        console.log(`\n  ${yellow("The terminal app is not installed on this machine.")}\n`);
+        console.log(`  ${bold("cargo install --path .")}  ${dim("from the kyb-tui checkout")}\n`);
+        process.exit(1);
+    }
+    const result = spawnSync(binary, args, { stdio: "inherit" });
+    // Exit with what it exited with: a wrapper that always reports success makes
+    // the thing it wraps untestable from a script.
+    if (result.error) {
+        console.error(`\n  Could not start the terminal app: ${result.error.message}\n`);
+        process.exit(1);
+    }
+    process.exit(result.status ?? 0);
+}

package/dist/upgrade.js

@@ -1,5 +1,6 @@
-import { readFileSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
+import { upsertEnv } from "./envfile.js";
 import { EVE_VERSION, bold, capture, dim, green, red, run, yellow } from "./util.js";
 /**
  * Which packages to upgrade: every `@kybernesis/*` this agent depends on.
@@ -56,12 +57,43 @@ function warnIfStale() {
         `compiled into this tool, so an old kyb reports an old pin as current.`);
     console.log(`    ${dim("npm install -g @kybernesis/create@latest")}\n`);
 }
+/**
+ * Raise the local queue's delivery timeouts on an agent that already exists.
+ *
+ * @remarks
+ * Written as a repair rather than a warning because of what the bug looks like
+ * from outside: the agent answers the same question twice, in two different
+ * wordings, and no error appears in any log. Nobody reports that as a transport
+ * problem, so a warning would be read past — and the correct value is not a
+ * judgement call, it is "longer than a turn".
+ *
+ * Only for self-hosted agents. Hosted ones use real queue infrastructure and
+ * never touch this transport, so the variables would be noise in their
+ * environment.
+ */
+function repairLocalQueueTimeouts(cwd, deps) {
+    if (!deps["@kybernesis/exe"])
+        return;
+    const path = join(cwd, ".env.local");
+    if (!existsSync(path))
+        return;
+    const text = readFileSync(path, "utf8");
+    const missing = ["WORKFLOW_LOCAL_HEADERS_TIMEOUT_MS", "WORKFLOW_LOCAL_BODY_TIMEOUT_MS"].filter((name) => !new RegExp(`^${name}=`, "m").test(text));
+    if (missing.length === 0)
+        return;
+    upsertEnv(cwd, Object.fromEntries(missing.map((name) => [name, "900000"])));
+    console.log(`  ${green("+")} raised the local queue delivery timeout in .env.local ${dim("(was 30s)")}\n` +
+        `    ${dim("A delivery holds one connection open for the whole turn. Below this, any turn")}\n` +
+        `    ${dim("slower than 30s was redelivered and its steps re-run — the agent answered twice.")}\n` +
+        `    ${dim("Takes effect on the next server restart.")}\n`);
+}
 export async function upgrade(skipEval) {
     const cwd = process.cwd();
     const pkg = JSON.parse(readFileSync(join(cwd, "package.json"), "utf8"));
     const deps = { ...pkg.dependencies, ...pkg.devDependencies };
     console.log(bold("\nkyb upgrade — checking @kybernesis/* and eve against npm\n"));
     warnIfStale();
+    repairLocalQueueTimeouts(cwd, deps);
     const toUpgrade = [];
     const unresolved = [];
     for (const name of kybernesisPackages(deps)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kybernesis/create",
-  "version": "0.9.0",
+  "version": "0.11.0",
   "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",