create-open-autonomy 2.3.4 → 2.3.6

package/README.md

@@ -31,7 +31,7 @@ LICENSE              Apache-2.0, seeded; the project's own
 package.json, test/  the project's own check (`bun run check`), starting with one test
 hermes/              the agent: SOUL.md, its two skills (develop, pm; a project's own skills live beside them, in hermes/skills/<project>/, and are the project's), profiles/treasurer (the second profile: the one that pays), kanban.seed.json (the board's first tasks, in order),
                      cron/jobs.seed.json (the PM, hourly), config.yaml (the model: the project's own choice), the seed hook
-.open-autonomy/      the platform connection: config.yaml (account, publish policy, rail bounds), reporter.ts (the publisher:
+.open-autonomy/      the platform connection: config.yaml (account, publish policy, the model and rail bounds the platform holds the project's funds to), reporter.ts (the publisher:
                      sessions, the board, the setup), mint-key.ts (the key, the adopter way), start.ts (the agent's four
                      processes, the one way it starts), the vendored SDK, kit.json (which kit, version and parameters made this repository)
 container/           a real setup: one image whose entrypoint is start.ts as root, dropping the gateway to the image's user; the pinned Hermes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-open-autonomy",
-  "version": "2.3.4",
+  "version": "2.3.6",
   "description": "The default Open Autonomy starter kit: a complete repository that runs its own Hermes agent against the platform, with the SDK wired in. `bun create open-autonomy <dir>` scaffolds one.",
   "license": "Apache-2.0",
   "repository": {
@@ -28,7 +28,7 @@
     "check": "bunx tsc --noEmit"
   },
   "dependencies": {
-    "@open-autonomy/sdk": "2.2.0"
+    "@open-autonomy/sdk": "2.3.1"
   },
   "devDependencies": {
     "@types/bun": "^1.3.10",

package/src/kit.ts

@@ -9,7 +9,7 @@
 import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
 import { dirname, join, relative, resolve } from 'node:path';
 
-export const KIT = { name: 'hermes', version: '2.3.4' } as const;
+export const KIT = { name: 'hermes', version: '2.3.6' } as const;
 export const KIT_FILE = '.open-autonomy/kit.json';
 const TEMPLATE = resolve(import.meta.dir, '..', 'template');
 
@@ -17,9 +17,9 @@ export interface KitParams { project: string; account: string }
 export interface KitRecord { kit: string; version: string; params: KitParams; divergences: string[] }
 
 // What the kit keeps current. Everything else in the template is seeded once.
-// A project's own, seeded once: its config, its board seed, its schedule, and any skill of its own outside
-// hermes/skills/open-autonomy/ (the kit's two).
-const OWNED = [/^hermes\/(?!config\.yaml$|kanban\.seed\.json$|cron\/jobs\.seed\.json$|skills\/(?!open-autonomy\/))/, /^\.open-autonomy\/(reporter\.ts|mint-key\.ts|start\.ts|package\.json|sdk\/)/, /^container\//, /^\.github\/workflows\/(ci|land)\.yml$/];
+// A project's own, seeded once: its config (the treasurer's too: the model is the project's choice for both profiles),
+// its board seed, its schedule, and any skill of its own outside hermes/skills/open-autonomy/ (the kit's two).
+const OWNED = [/^hermes\/(?!config\.yaml$|kanban\.seed\.json$|cron\/jobs\.seed\.json$|profiles\/treasurer\/config\.yaml$|skills\/(?!open-autonomy\/))/, /^\.open-autonomy\/(reporter\.ts|mint-key\.ts|start\.ts|package\.json|sdk\/)/, /^container\//, /^\.github\/workflows\/(ci|land)\.yml$/];
 export const isOwned = (rel: string): boolean => OWNED.some((re) => re.test(rel));
 
 export function validateParams(p: Partial<KitParams>): KitParams {

package/template/.open-autonomy/config.yaml

@@ -15,6 +15,15 @@ publish:
 # environment), and where it keeps its own cursor (beside this file).
 state_file: reporter-state.json
 
+# The models the project's funds may buy on the platform's model rail: a bound the platform reads from this file and
+# holds whatever a key was minted with. Empty: any model the gateway serves (`GET /v1/catalog` lists them).
+models: [zai/glm-5.3-flash]
+
+# The most the project's funds may spend on the platform's model rail in a day (UTC): a bound the platform holds at every
+# call, so a runaway stops at the owner's number. 0: no bound of the project's own beyond the platform's global rail.
+spend:
+  daily_usd_cents: 500
+
 # The rails the agent may spend through beyond model calls, and the owner's bounds on each. Off unless a
 # bound is set. Every rail leaves a record on the public audit trail naming itself.
 rails:

package/template/.open-autonomy/start.ts

@@ -6,6 +6,11 @@
 //
 //   bun .open-autonomy/start.ts [--home <dir>] [--secrets <dir>] [--project <dir>] [--origin <url>] [--as <user>] [--valve <port>]
 //
+// <secrets>/codex.json, when present, is the owner's ChatGPT/Codex subscription login (the Codex CLI's auth.json
+// tokens): the valve serves it on the third port, and the home's .env names it (HERMES_CODEX_BASE_URL) for a custom
+// provider in the project's config that speaks the Codex protocol — the model runs on the subscription, the login
+// never enters the agent.
+//
 // The processes, in order:
 //   ssh-agent   holds <secrets>/deploy_key, its socket at <home>/ssh-agent.sock; the gateway pushes through it
 //               and never holds the key (absent: pushes are your own git's business)
@@ -89,8 +94,11 @@ if (existsSync(committed)) {
 }
 // The home's .env is the home's own, except the valve's three lines, which are this start's truth on every start.
 const envFile = resolve(home, '.env');
-const kept = existsSync(envFile) ? readFileSync(envFile, 'utf8').split('\n').filter((l) => l.trim() && !/^OPEN_AUTONOMY_(BASE_URL|PAY_URL|KEY)=/.test(l)) : [];
-const lines = [`OPEN_AUTONOMY_BASE_URL=${baseUrl}`, `OPEN_AUTONOMY_PAY_URL=${payUrl}`, 'OPEN_AUTONOMY_KEY=valve', ...kept];
+const kept = existsSync(envFile) ? readFileSync(envFile, 'utf8').split('\n').filter((l) => l.trim() && !/^(OPEN_AUTONOMY_(BASE_URL|PAY_URL|KEY)|HERMES_CODEX_BASE_URL)=/.test(l)) : [];
+// The Codex subscription's address goes in the .env too: Hermes loads the home's .env into every process it starts,
+// including the scheduler's job runners, which do not inherit the gateway's environment.
+const codexBase = existsSync(resolve(secrets, 'codex.json')) ? [`HERMES_CODEX_BASE_URL=http://127.0.0.1:${valvePort + 2}/backend-api/codex`] : [];
+const lines = [`OPEN_AUTONOMY_BASE_URL=${baseUrl}`, `OPEN_AUTONOMY_PAY_URL=${payUrl}`, 'OPEN_AUTONOMY_KEY=valve', ...codexBase, ...kept];
 // On the first start, what the environment says about the agent's channels comes along: Discord's, and GitHub's for a community desk.
 if (!existsSync(envFile)) for (const k of Object.keys(process.env).sort()) if (/^(DISCORD_|GITHUB_TOKEN$|GITHUB_API_URL$)/.test(k) && process.env[k]) lines.push(`${k}=${process.env[k]}`);
 writeFileSync(envFile, `${lines.join('\n')}\n`);
@@ -102,19 +110,17 @@ const keys: string[] = [];
 if (existsSync(resolve(secrets, 'agent.env'))) keys.push('--key', `${resolve(secrets, 'agent.env')}:${valvePort}`);
 if (existsSync(resolve(secrets, 'treasurer.env'))) keys.push('--key', `${resolve(secrets, 'treasurer.env')}:${valvePort + 1}`);
 if (!keys.length) { console.error(`start: no ${resolve(secrets, 'agent.env')} — mint the developer's key: bun .open-autonomy/mint-key.ts`); process.exit(1); }
-if (user) {
-  // The whole point of --as: the agent's user must not be able to read a key.
-  const peek = Bun.spawnSync({ cmd: drop(['cat', resolve(secrets, 'agent.env')]), stdout: 'pipe', stderr: 'pipe' });
-  if (peek.exitCode === 0) { console.error(`start: ${resolve(secrets, 'agent.env')} is readable by ${user.name}; the secrets must belong to root alone`); process.exit(1); }
-}
-// The valve and the reporter run from this script's own directory (its node_modules, its vendored SDK): in a
-// container that is the image's copy, and the checkout only has to be the project.
+// The Codex subscription: the valve holds the login and serves it on the third port; Hermes reaches it as a named
+// custom provider speaking the Codex protocol (base_url ${HERMES_CODEX_BASE_URL}, api_key `valve`), which the home's .env names.
+const codexFile = resolve(secrets, 'codex.json');
+const codexPort = valvePort + 2;
+if (existsSync(codexFile)) keys.push('--codex', `${codexFile}:${codexPort}`);
 spawn('valve', ['bun', resolve(import.meta.dir, 'sdk', 'valve.ts'), ...keys], {});
 
 // 5. The reporter and the gateway, as the agent.
 const env = agentEnv();
 spawn('reporter', ['bun', resolve(import.meta.dir, 'reporter.ts'), '--config', resolve(project, '.open-autonomy', 'config.yaml')], { asAgent: true, env: { ...env, OPEN_AUTONOMY_BASE_URL: baseUrl } });
 spawn('gateway', ['hermes', 'gateway', 'run'], { asAgent: true, env });
-say(`gateway up in ${project} as ${user?.name ?? userInfo().username}, home ${home}; the valve on :${valvePort}${keys.length > 2 ? ` and :${valvePort + 1}` : ''}`);
+say(`gateway up in ${project} as ${user?.name ?? userInfo().username}, home ${home}; the valve on :${valvePort}${existsSync(resolve(secrets, 'treasurer.env')) ? ` and :${valvePort + 1}` : ''}${existsSync(codexFile) ? `; the Codex subscription on :${codexPort}` : ''}`);
 if (!readFileSync(resolve(project, '.open-autonomy', 'config.yaml'), 'utf8').includes('account:')) say('warning: .open-autonomy/config.yaml names no account');
 await new Promise(() => {});