create-loopengine 0.1.14 → 0.1.16

package/README.md

@@ -61,8 +61,8 @@ own `discoverAgents`: it scans `agents/` and keys each entry by
 one new file, not a rewrite and not a registry edit either. See
 [loopengine's own README](https://github.com/evanyan22/loopengine) for the
 full `AgentConfig` surface: permission rules, skills, context-budget
-recovery, and how to wire a real model (Anthropic, OpenAI, or DeepSeek —
-all three included).
+recovery, and how to wire a real model (Anthropic, OpenAI, DeepSeek,
+Kimi, GLM, or Gemini — all six included).
 
 ## Add another agent
 
@@ -115,10 +115,60 @@ Each of the five template-owned files gets one of:
   as any git merge conflict — resolve them by hand, then `npx tsc
   --noEmit` to confirm it builds.
 
-`upgrade` never touches `agents/`, `README.md`, `.env.example`, or
-`package.json`'s own dependency versions — run `npm install
-loopengine@latest` (and `actauth`/`skillgarden` if you use them directly)
-separately to pick those up.
+`upgrade` also bumps whichever of `loopengine`/`actauth`/`skillgarden`
+are already in your `package.json` to their latest published version
+(never adds one you don't already depend on) and runs `npm install` for
+you — a merged file that now calls a newer export is a silent, hard-to-
+notice failure if the installed package hasn't actually caught up, so
+this isn't left as a manual step. If the install itself fails (offline,
+a registry hiccup), the version bump is still written to `package.json`;
+just run `npm install` yourself to finish.
+
+`upgrade` never touches `agents/`, `README.md`, `.env.example`, or any
+dependency *other* than those three.
+
+## Running in production
+
+`npm run dev` (`tsx watch`) restarts on every file change — fine for
+local iteration, wrong for a real server, since a restart drops every
+in-flight request and any pending live approval/question (see
+loopengine's own README on durable vs. live approvers if that matters to
+you). Use [pm2](https://pm2.keymetrics.io/) to run the plain, non-watch
+server instead, with restart-on-crash:
+
+```bash
+pm2 start npx --name my-agents --interpreter none -- loopengine serve
+pm2 save                # persist across reboots
+pm2 startup              # (one-time) launch pm2 itself on boot
+```
+
+`--interpreter none` matters — without it pm2 may try to run `npx`
+through `node` directly, which fails since it's a shell-invokable binary,
+not a bare `.js` file. `--` separates pm2's own flags from the command's
+own args (`loopengine serve`).
+
+Two gotchas worth knowing before they cost you a debugging session:
+
+- **`npm` is not `npx`.** `pm2 start npm --name my-agents -- loopengine
+  serve` does *not* work — `npm <args>` treats its args as npm's own
+  subcommands, not a binary to run, so it fails with `Unknown command:
+  "loopengine"`. If you'd rather invoke via `npm`, add a `"start":
+  "loopengine serve"` script to `package.json` first, then `pm2 start npm
+  --name my-agents -- start` (npm special-cases `start` as a shorthand
+  for running that script, unlike arbitrary script names).
+- **pm2 remembers a name's original `cwd`/script, not whatever you pass
+  next time.** Running `pm2 start ... --name my-agents` again after
+  moving/recreating the project directory just restarts the *already-
+  registered* process with its *original* path — your new files are
+  never even read. Run `pm2 delete my-agents` first if the project's
+  location changed, then start fresh.
+
+`pm2 logs my-agents` tails output; `pm2 restart my-agents` after any
+manual edit to `adapters/http.ts`/`adapters/cli.ts`/`agent-registry.ts`
+(see "Upgrading" above) or an env var change — those don't take effect
+until the process restarts. Adding a skill or tool through the Admin UI
+does *not* need a restart — that's applied to the already-running process
+directly.
 
 ## Status
 

package/dist/cli.d.ts

@@ -11,10 +11,29 @@ export interface UpgradeFileResult {
     file: string;
     status: UpgradeFileStatus;
 }
+export interface UpgradeDependencyResult {
+    name: string;
+    from: string;
+    to: string;
+}
 export interface UpgradeResult {
     fromVersion: string;
     toVersion: string;
     files: UpgradeFileResult[];
+    /** Which of loopengine/actauth/skillgarden actually had their
+     * package.json range bumped — only ones already present as a
+     * dependency, never newly added (see bumpDependencies's own doc
+     * comment). Empty if the project has no package.json, or every present
+     * one was already at the latest range. */
+    dependencies: UpgradeDependencyResult[];
+    /** Only attempted when `dependencies` is non-empty — running `npm
+     * install` for a project with nothing to bump would be pointless. */
+    npmInstall?: {
+        ok: true;
+    } | {
+        ok: false;
+        error: string;
+    };
 }
 export interface UpgradeOptions {
     /** Defaults to process.cwd(). */
@@ -31,6 +50,13 @@ export interface UpgradeOptions {
      * (a real `npm pack`). Test-only seam to avoid hitting the real
      * registry for a fixture "old" template. */
     resolveBaseTemplateDir?: (version: string) => string;
+    /** Resolves a package's current latest version — defaults to a real
+     * `npm view <pkg> version`. Test-only seam to avoid hitting the real
+     * registry. */
+    resolveLatestVersion?: (pkg: string) => string;
+    /** Runs `npm install` in projectDir — defaults to a real one. Test-only
+     * seam to avoid actually installing anything during tests. */
+    runNpmInstall?: (projectDir: string) => void;
 }
 export declare function upgradeProject(options?: UpgradeOptions): UpgradeResult;
 export declare function main(argv?: string[]): void;

package/dist/cli.js

@@ -163,8 +163,76 @@ export function upgradeProject(options = {}) {
     const resolveBase = options.resolveBaseTemplateDir ?? fetchPublishedTemplateDir;
     const baseTemplateDir = resolveBase(fromVersion);
     const files = UPGRADE_CANDIDATE_FILES.map((candidate) => upgradeFile(candidate, baseTemplateDir, currentTemplateDir, projectDir));
+    const resolveLatestVersion = options.resolveLatestVersion ?? resolveLatestVersionFromNpm;
+    const dependencies = bumpDependencies(projectDir, resolveLatestVersion);
+    let npmInstall;
+    if (dependencies.length > 0) {
+        const install = options.runNpmInstall ?? runRealNpmInstall;
+        try {
+            install(projectDir);
+            npmInstall = { ok: true };
+        }
+        catch (err) {
+            // Non-fatal — the file merge and the package.json bump already
+            // succeeded and are on disk either way; a failed install (offline,
+            // a registry hiccup) just means the operator runs `npm install`
+            // themselves, the same single command this was trying to save them
+            // from typing, not a reason to unwind everything already done.
+            npmInstall = { ok: false, error: err instanceof Error ? err.message : String(err) };
+        }
+    }
     writeFileSync(provenancePath, JSON.stringify({ version: toVersion }, null, 2) + '\n');
-    return { fromVersion, toVersion, files };
+    return { fromVersion, toVersion, files, dependencies, npmInstall };
+}
+function resolveLatestVersionFromNpm(pkg) {
+    return execFileSync('npm', ['view', pkg, 'version'], { stdio: 'pipe' }).toString().trim();
+}
+function runRealNpmInstall(projectDir) {
+    execFileSync('npm', ['install'], { cwd: projectDir, stdio: 'pipe' });
+}
+// Only loopengine/actauth/skillgarden — the three packages a scaffolded
+// project's own adapters/http.ts can import directly (see this repo's own
+// README on why: template code that imports a package must declare it as
+// its own direct dependency, not rely on loopengine's transitive one) —
+// and only ones already present in the project's own package.json.
+// Deliberately never *adds* a dependency a project doesn't already have:
+// this command upgrades what's there, it doesn't decide what a project
+// should depend on.
+const UPGRADABLE_DEPENDENCIES = ['loopengine', 'actauth', 'skillgarden'];
+/** Bumps package.json's dependency ranges for whichever of
+ * loopengine/actauth/skillgarden are already present, to `^<latest>` —
+ * run automatically as part of `upgrade` (not left as a manual follow-up
+ * step) because a project whose merged template code now calls a newer
+ * export, but whose installed package is still old, fails silently: no
+ * conflict marker, no build error, just a feature that's quietly not
+ * there yet (confirmed live — this exact gap is what prompted adding this
+ * function in the first place, see this repo's own git history). Returns
+ * [] untouched if the project has no package.json at all, same
+ * "can't merge what isn't there" reasoning upgradeFile's own missing-file
+ * check uses. */
+function bumpDependencies(projectDir, resolveLatestVersion) {
+    const pkgPath = join(projectDir, 'package.json');
+    if (!existsSync(pkgPath))
+        return [];
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+    const deps = pkg.dependencies;
+    if (!deps)
+        return [];
+    const changes = [];
+    for (const name of UPGRADABLE_DEPENDENCIES) {
+        const currentRange = deps[name];
+        if (currentRange === undefined)
+            continue;
+        const latest = resolveLatestVersion(name);
+        const newRange = `^${latest}`;
+        if (currentRange === newRange)
+            continue;
+        deps[name] = newRange;
+        changes.push({ name, from: currentRange, to: newRange });
+    }
+    if (changes.length > 0)
+        writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
+    return changes;
 }
 function parseUpgradeArgs(argv) {
     let from;
@@ -187,7 +255,18 @@ function printUpgradeSummary(result) {
         console.log(`${conflicted.length} file(s) have <<<<<<< conflict markers to resolve by hand before this will build.`);
     }
     else {
-        console.log('No conflicts. Run `npm install loopengine@latest` to pick up any library-side changes too.');
+        console.log('No conflicts.');
+    }
+    if (result.dependencies.length > 0) {
+        console.log();
+        for (const dep of result.dependencies)
+            console.log(`  ${dep.name}: ${dep.from} -> ${dep.to}`);
+        if (result.npmInstall?.ok) {
+            console.log('npm install completed.');
+        }
+        else if (result.npmInstall) {
+            console.log(`npm install failed (${result.npmInstall.error}) — run it yourself to finish picking up the new versions.`);
+        }
     }
 }
 function parseArgs(argv) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-loopengine",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "description": "Scaffold a new loopengine agent project — a runnable HTTP server with one example agent, in your own repo.",
   "license": "MIT",
   "type": "module",

package/template/adapters/http.ts

@@ -645,7 +645,14 @@ function parseAgentTemplateOptions(body: Record<string, unknown>): { ok: true; v
       return { ok: false, error: 'model must be an object' }
     }
     const provider = (body.model as Record<string, unknown>).provider
-    if (provider !== 'anthropic' && provider !== 'openai' && provider !== 'deepseek') {
+    if (
+      provider !== 'anthropic' &&
+      provider !== 'openai' &&
+      provider !== 'deepseek' &&
+      provider !== 'kimi' &&
+      provider !== 'glm' &&
+      provider !== 'gemini'
+    ) {
       return { ok: false, error: `unsupported model provider '${String(provider)}'` }
     }
     const modelName = (body.model as Record<string, unknown>).model

package/template/package.json

@@ -9,7 +9,7 @@
     "cli": "tsx adapters/cli.ts"
   },
   "dependencies": {
-    "loopengine": "^0.1.6",
+    "loopengine": "^0.1.7",
     "actauth": "^0.0.12",
     "skillgarden": "^0.0.9"
   },