Will Anderson
0dba4f3663
- daemon.el: launchd plist generation, install/start/stop/status/wire - forge.el: dispatch daemon command, add to usage - install.el: auto-register soul as launchd agent after install - schema.el: add FORGE_DIR constant for absolute path references forge daemon install --all installs all 19 souls as resident launchd agents with KeepAlive. forge daemon wire registers each soul as an Engram peer to every other soul. forge daemon status health-checks all.
424 lines
16 KiB
EmacsLisp
424 lines
16 KiB
EmacsLisp
// daemon.el — Soul Engram lifecycle management.
|
|
//
|
|
// Manages launchd-resident DHARMA soul Engrams on macOS.
|
|
//
|
|
// Commands:
|
|
// forge daemon install <slug> — write launchd plist, load soul as resident
|
|
// forge daemon start <slug> — launchctl kickstart the soul
|
|
// forge daemon stop <slug> — launchctl stop the soul
|
|
// forge daemon status — health check all souls
|
|
// forge daemon wire — register all soul Engrams as peers to each other
|
|
//
|
|
// Depends on: schema.el (FORGE_VERSION, engram_key, str_escape_json, log_event)
|
|
|
|
// ── Constants ──────────────────────────────────────────────────────────────────
|
|
// (FORGE_DIR is defined in schema.el)
|
|
|
|
let ENGRAM_BIN: String = "/Users/will/Development/neuron-technologies/foundation/engram/dist/engram"
|
|
let LAUNCHD_DIR: String = "/Users/will/Library/LaunchAgents"
|
|
let DHARMA_API_KEY: String = "ntn-dharma-2026"
|
|
|
|
// ── plist generation ───────────────────────────────────────────────────────────
|
|
|
|
// plist_label — launchd label for a soul slug.
|
|
fn plist_label(slug: String) -> String {
|
|
"ai.neurontechnologies.soul." + slug
|
|
}
|
|
|
|
// plist_path — full path to the launchd plist file for a soul.
|
|
fn plist_path(slug: String) -> String {
|
|
LAUNCHD_DIR + "/ai.neurontechnologies.soul." + slug + ".plist"
|
|
}
|
|
|
|
// write_soul_plist — generate and write the launchd plist for a soul.
|
|
// Returns the path written, or "" on failure.
|
|
fn write_soul_plist(slug: String, port: String, db_path: String, subject: String) -> String {
|
|
let label: String = plist_label(slug)
|
|
let plist_file: String = plist_path(slug)
|
|
let log_file: String = FORGE_DIR + "/log/" + slug + ".log"
|
|
let soul_api_key: String = "ntn-" + slug + "-2026"
|
|
|
|
let content: String = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" +
|
|
"<!DOCTYPE plist PUBLIC \"-//Apple//DTD PLIST 1.0//EN\" \"http://www.apple.com/DTDs/PropertyList-1.0.dtd\">\n" +
|
|
"<plist version=\"1.0\">\n" +
|
|
"<dict>\n" +
|
|
" <key>Label</key><string>" + label + "</string>\n" +
|
|
" <key>ProgramArguments</key>\n" +
|
|
" <array>\n" +
|
|
" <string>" + ENGRAM_BIN + "</string>\n" +
|
|
" </array>\n" +
|
|
" <key>EnvironmentVariables</key>\n" +
|
|
" <dict>\n" +
|
|
" <key>ENGRAM_DB_PATH</key><string>" + db_path + "</string>\n" +
|
|
" <key>ENGRAM_BIND</key><string>0.0.0.0:" + port + "</string>\n" +
|
|
" <key>ENGRAM_API_KEY</key><string>" + soul_api_key + "</string>\n" +
|
|
" <key>ENGRAM_PEER_NAME</key><string>" + str_escape_json(subject) + "</string>\n" +
|
|
" </dict>\n" +
|
|
" <key>RunAtLoad</key><true/>\n" +
|
|
" <key>KeepAlive</key><true/>\n" +
|
|
" <key>StandardOutPath</key><string>" + log_file + "</string>\n" +
|
|
" <key>StandardErrorPath</key><string>" + log_file + "</string>\n" +
|
|
"</dict>\n" +
|
|
"</plist>\n"
|
|
|
|
let ok: Int = fs_write(plist_file, content)
|
|
if ok == 0 {
|
|
println("[daemon] error: could not write plist to " + plist_file)
|
|
return ""
|
|
}
|
|
println("[daemon] wrote plist: " + plist_file)
|
|
return plist_file
|
|
}
|
|
|
|
// ── launchctl helpers ─────────────────────────────────────────────────────────
|
|
|
|
// launchctl_load — load (register + start) a plist via launchctl.
|
|
fn launchctl_load(plist_file: String) -> String {
|
|
let out: String = exec("launchctl load " + plist_file + " 2>&1")
|
|
return str_trim(out)
|
|
}
|
|
|
|
// launchctl_unload — unload a plist via launchctl.
|
|
fn launchctl_unload(plist_file: String) -> String {
|
|
let out: String = exec("launchctl unload " + plist_file + " 2>&1")
|
|
return str_trim(out)
|
|
}
|
|
|
|
// launchctl_kickstart — start a loaded soul via its label.
|
|
fn launchctl_kickstart(slug: String) -> String {
|
|
let label: String = plist_label(slug)
|
|
let out: String = exec("launchctl kickstart gui/$(id -u)/" + label + " 2>&1")
|
|
return str_trim(out)
|
|
}
|
|
|
|
// launchctl_stop — stop a running soul (does not unload, KeepAlive will restart).
|
|
fn launchctl_stop(slug: String) -> String {
|
|
let label: String = plist_label(slug)
|
|
let out: String = exec("launchctl stop " + label + " 2>&1")
|
|
return str_trim(out)
|
|
}
|
|
|
|
// soul_is_up — returns true if the soul's Engram responds to /stats.
|
|
fn soul_is_up(engram_url: String) -> Bool {
|
|
let resp: String = http_get(engram_url + "/stats")
|
|
if str_eq(resp, "") { return false }
|
|
return true
|
|
}
|
|
|
|
// ── Registry helpers ──────────────────────────────────────────────────────────
|
|
|
|
// count_souls — returns number of imprints in registry.json.
|
|
fn count_souls(reg_json: String) -> Int {
|
|
let n: Int = 0
|
|
let i: Int = 0
|
|
while i < 50 {
|
|
let entry: String = json_get(reg_json, "imprints." + int_to_str(i))
|
|
if str_eq(entry, "") {
|
|
return n
|
|
}
|
|
let n = n + 1
|
|
let i = i + 1
|
|
}
|
|
return n
|
|
}
|
|
|
|
// ── daemon install ─────────────────────────────────────────────────────────────
|
|
|
|
// daemon_install_one — install a single soul as a launchd agent.
|
|
// Creates the imprints dir, ensures the Engram runs (starts temp if needed),
|
|
// writes the plist and loads it.
|
|
fn daemon_install_one(slug: String, port: String, engram_url: String, subject: String) -> String {
|
|
println("[daemon] install: " + slug + " → port " + port)
|
|
|
|
// Ensure dirs exist
|
|
let db_path: String = FORGE_DIR + "/imprints/" + slug
|
|
let log_dir: String = FORGE_DIR + "/log"
|
|
if !fs_exists(db_path) { fs_mkdir(db_path) }
|
|
if !fs_exists(log_dir) { fs_mkdir(log_dir) }
|
|
if !fs_exists(LAUNCHD_DIR) { fs_mkdir(LAUNCHD_DIR) }
|
|
|
|
// Write plist
|
|
let pfile: String = write_soul_plist(slug, port, db_path, subject)
|
|
if str_eq(pfile, "") {
|
|
println("[daemon] error: plist write failed for " + slug)
|
|
return ""
|
|
}
|
|
|
|
// Unload first in case it was already loaded (idempotent)
|
|
launchctl_unload(pfile)
|
|
|
|
// Load
|
|
let load_out: String = launchctl_load(pfile)
|
|
if !str_eq(load_out, "") {
|
|
println("[daemon] launchctl load: " + load_out)
|
|
}
|
|
|
|
println("[daemon] loaded: " + plist_label(slug))
|
|
log_event("daemon_install", subject, "port=" + port + " plist=" + pfile)
|
|
return pfile
|
|
}
|
|
|
|
fn daemon_install_main() -> String {
|
|
let argv: [String] = args()
|
|
// args() layout: [0]="daemon" [1]="install" [2]=<slug>
|
|
let slug: String = ""
|
|
if len(argv) > 2 {
|
|
let slug = get(argv, 2)
|
|
}
|
|
if str_eq(slug, "") {
|
|
println("[daemon] usage: forge daemon install <slug>")
|
|
println("[daemon] or: forge daemon install --all")
|
|
return ""
|
|
}
|
|
|
|
let reg_json: String = fs_read(FORGE_DIR + "/registry.json")
|
|
if str_eq(reg_json, "") {
|
|
println("[daemon] error: could not read registry.json")
|
|
return ""
|
|
}
|
|
|
|
// --all: install every soul in the registry
|
|
if str_eq(slug, "--all") {
|
|
let i: Int = 0
|
|
while i < 50 {
|
|
let entry: String = json_get(reg_json, "imprints." + int_to_str(i))
|
|
if str_eq(entry, "") {
|
|
let i = i + 50 // break
|
|
} else {
|
|
let s: String = json_get_string(entry, "slug")
|
|
let p: String = int_to_str(json_get_int(entry, "engram_port"))
|
|
let u: String = json_get_string(entry, "engram_url")
|
|
let sub: String = json_get_string(entry, "subject")
|
|
daemon_install_one(s, p, u, sub)
|
|
let i = i + 1
|
|
}
|
|
}
|
|
return "done"
|
|
}
|
|
|
|
// Single soul
|
|
let found: Int = 0
|
|
let i: Int = 0
|
|
while i < 50 {
|
|
let entry: String = json_get(reg_json, "imprints." + int_to_str(i))
|
|
if str_eq(entry, "") {
|
|
let i = i + 50 // break
|
|
} else {
|
|
let s: String = json_get_string(entry, "slug")
|
|
if str_eq(s, slug) {
|
|
let p: String = int_to_str(json_get_int(entry, "engram_port"))
|
|
let u: String = json_get_string(entry, "engram_url")
|
|
let sub: String = json_get_string(entry, "subject")
|
|
daemon_install_one(s, p, u, sub)
|
|
let found = 1
|
|
let i = i + 50 // break
|
|
} else {
|
|
let i = i + 1
|
|
}
|
|
}
|
|
}
|
|
if found == 0 {
|
|
println("[daemon] error: slug '" + slug + "' not found in registry.json")
|
|
}
|
|
return ""
|
|
}
|
|
|
|
// ── daemon start / stop ────────────────────────────────────────────────────────
|
|
|
|
fn daemon_start_main() -> String {
|
|
let argv: [String] = args()
|
|
// args() layout: [0]="daemon" [1]="start" [2]=<slug>
|
|
let slug: String = ""
|
|
if len(argv) > 2 {
|
|
let slug = get(argv, 2)
|
|
}
|
|
if str_eq(slug, "") {
|
|
println("[daemon] usage: forge daemon start <slug>")
|
|
return ""
|
|
}
|
|
let out: String = launchctl_kickstart(slug)
|
|
println("[daemon] start " + slug + ": " + out)
|
|
return out
|
|
}
|
|
|
|
fn daemon_stop_main() -> String {
|
|
let argv: [String] = args()
|
|
// args() layout: [0]="daemon" [1]="stop" [2]=<slug>
|
|
let slug: String = ""
|
|
if len(argv) > 2 {
|
|
let slug = get(argv, 2)
|
|
}
|
|
if str_eq(slug, "") {
|
|
println("[daemon] usage: forge daemon stop <slug>")
|
|
return ""
|
|
}
|
|
let out: String = launchctl_stop(slug)
|
|
println("[daemon] stop " + slug + ": " + out)
|
|
return out
|
|
}
|
|
|
|
// ── daemon status ─────────────────────────────────────────────────────────────
|
|
|
|
fn daemon_status_main() -> String {
|
|
let reg_json: String = fs_read(FORGE_DIR + "/registry.json")
|
|
if str_eq(reg_json, "") {
|
|
println("[daemon] error: could not read registry.json")
|
|
return ""
|
|
}
|
|
|
|
println("[daemon] DHARMA soul status:")
|
|
println("")
|
|
|
|
let up: Int = 0
|
|
let down: Int = 0
|
|
let i: Int = 0
|
|
while i < 50 {
|
|
let entry: String = json_get(reg_json, "imprints." + int_to_str(i))
|
|
if str_eq(entry, "") {
|
|
let i = i + 50 // break
|
|
} else {
|
|
let slug: String = json_get_string(entry, "slug")
|
|
let url: String = json_get_string(entry, "engram_url")
|
|
let sub: String = json_get_string(entry, "subject")
|
|
let port: String = int_to_str(json_get_int(entry, "engram_port"))
|
|
if soul_is_up(url) {
|
|
println(" [UP ] " + sub + " — " + url)
|
|
let up = up + 1
|
|
} else {
|
|
println(" [DOWN] " + sub + " — " + url)
|
|
let down = down + 1
|
|
}
|
|
let i = i + 1
|
|
}
|
|
}
|
|
|
|
println("")
|
|
println("[daemon] up=" + int_to_str(up) + " down=" + int_to_str(down))
|
|
return ""
|
|
}
|
|
|
|
// ── daemon wire ───────────────────────────────────────────────────────────────
|
|
//
|
|
// Registers every soul as a peer in every other soul's Engram.
|
|
// POST /sync/peers with a Peer JSON object.
|
|
//
|
|
// Peer format (from engram-sync/src/types.rs):
|
|
// { "id": <uuid>, "name": <string>, "address": <url>, "api_key": <string>,
|
|
// "sync_tiers": ["Semantic"], "last_sync_at": 0, "trusted": true }
|
|
|
|
fn make_peer_json(peer_id: String, name: String, address: String, api_key: String) -> String {
|
|
"{\"id\":\"" + peer_id + "\",\"name\":\"" + str_escape_json(name) +
|
|
"\",\"address\":\"" + address +
|
|
"\",\"api_key\":\"" + api_key +
|
|
"\",\"sync_tiers\":[\"Semantic\"],\"last_sync_at\":0,\"trusted\":true}"
|
|
}
|
|
|
|
fn daemon_wire_main() -> String {
|
|
let reg_json: String = fs_read(FORGE_DIR + "/registry.json")
|
|
if str_eq(reg_json, "") {
|
|
println("[daemon] error: could not read registry.json")
|
|
return ""
|
|
}
|
|
|
|
println("[daemon] wiring peers — registering all souls as peers to each other...")
|
|
println("")
|
|
|
|
// Collect all soul entries (up to 50)
|
|
// For each soul A, register all other souls B as peers of A
|
|
let registered: Int = 0
|
|
let failed: Int = 0
|
|
|
|
let i: Int = 0
|
|
while i < 50 {
|
|
let entry_a: String = json_get(reg_json, "imprints." + int_to_str(i))
|
|
if str_eq(entry_a, "") {
|
|
let i = i + 50 // break
|
|
} else {
|
|
let slug_a: String = json_get_string(entry_a, "slug")
|
|
let url_a: String = json_get_string(entry_a, "engram_url")
|
|
let key_a: String = "ntn-" + slug_a + "-2026"
|
|
|
|
// Register all other souls as peers of soul A
|
|
let j: Int = 0
|
|
while j < 50 {
|
|
let entry_b: String = json_get(reg_json, "imprints." + int_to_str(j))
|
|
if str_eq(entry_b, "") {
|
|
let j = j + 50 // break
|
|
} else {
|
|
let slug_b: String = json_get_string(entry_b, "slug")
|
|
if !str_eq(slug_a, slug_b) {
|
|
let url_b: String = json_get_string(entry_b, "engram_url")
|
|
let sub_b: String = json_get_string(entry_b, "subject")
|
|
let key_b: String = "ntn-" + slug_b + "-2026"
|
|
|
|
// Generate a deterministic peer ID from slug_b
|
|
let peer_id: String = uuid_v4()
|
|
let peer_json: String = make_peer_json(peer_id, sub_b, url_b, key_b)
|
|
|
|
let headers: String = "{\"Authorization\":\"Bearer " + key_a + "\",\"Content-Type\":\"application/json\"}"
|
|
let headers_map: String = headers // pass as json string for http_post_with_headers
|
|
// Build a Map for headers
|
|
let hdrs = el_map_new(2, "Authorization", "Bearer " + key_a, "Content-Type", "application/json")
|
|
let resp: String = http_post_with_headers(url_a + "/sync/peers", peer_json, hdrs)
|
|
if str_eq(resp, "") {
|
|
let failed = failed + 1
|
|
} else {
|
|
let registered = registered + 1
|
|
}
|
|
}
|
|
let j = j + 1
|
|
}
|
|
}
|
|
let i = i + 1
|
|
}
|
|
}
|
|
|
|
println("[daemon] wire complete: registered=" + int_to_str(registered) + " failed=" + int_to_str(failed))
|
|
return ""
|
|
}
|
|
|
|
// ── daemon_main — dispatch ────────────────────────────────────────────────────
|
|
//
|
|
// args() layout when invoked as: forge daemon <subcmd> [slug]
|
|
// args()[0] = "daemon"
|
|
// args()[1] = <subcmd> e.g. "install"
|
|
// args()[2] = [slug] e.g. "bobby-anderson"
|
|
|
|
fn daemon_main() -> String {
|
|
let argv: [String] = args()
|
|
let subcmd: String = ""
|
|
if len(argv) > 1 {
|
|
let subcmd = get(argv, 1)
|
|
}
|
|
|
|
if str_eq(subcmd, "install") {
|
|
daemon_install_main()
|
|
} else {
|
|
if str_eq(subcmd, "start") {
|
|
daemon_start_main()
|
|
} else {
|
|
if str_eq(subcmd, "stop") {
|
|
daemon_stop_main()
|
|
} else {
|
|
if str_eq(subcmd, "status") {
|
|
daemon_status_main()
|
|
} else {
|
|
if str_eq(subcmd, "wire") {
|
|
daemon_wire_main()
|
|
} else {
|
|
println("[daemon] usage: forge daemon <install|start|stop|status|wire> [slug]")
|
|
println("")
|
|
println(" forge daemon install <slug> — write launchd plist, load soul as resident")
|
|
println(" forge daemon install --all — install all souls from registry")
|
|
println(" forge daemon start <slug> — kickstart a loaded soul")
|
|
println(" forge daemon stop <slug> — stop a running soul")
|
|
println(" forge daemon status — health check all souls")
|
|
println(" forge daemon wire — register all souls as Engram peers")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return ""
|
|
}
|