Archived
build DHARMA network: 19 soul Engram instances with full peer wiring
- Add scripts/: install_soul.py, install_all.py, launch_dharma.sh, stop_dharma.sh, wire_peers.py - Move all seeds into seeds/ directory (consolidated from root-level scattered files) - Update registry.json with engram_root_id, engram_api_key, engram_url for all 19 installed souls - Add src/soul.el, src/research.el; remove src/daemon.el - .gitignore: exclude imprints/, log/, sandboxes/ (runtime data) - Remove superseded scripts: deploy.py, install_imprints.py, reinstall_imprints.py, fix_collision.py - Remove old root-level seed files and shell scripts superseded by scripts/ versions Key: native engram binary uses _auth body field, per-soul keys ntn-<slug>-2026, DharmaPeer graph edges for peer wiring, sanitize_content() for JSON safety. 190/190 peer pairs wired successfully.
This commit is contained in:
Will Anderson
+835
@@ -0,0 +1,835 @@
|
||||
// soul.el — Soul Engram lifecycle management.
|
||||
//
|
||||
// Manages launchd-resident DHARMA soul Engrams on macOS.
|
||||
//
|
||||
// Commands:
|
||||
// forge soul install <slug> — write launchd plist, load soul as resident
|
||||
// forge soul start <slug> — launchctl kickstart the soul
|
||||
// forge soul stop <slug> — launchctl stop the soul
|
||||
// forge soul status — health check all souls
|
||||
// forge soul wire — register all soul Engrams as peers to each other
|
||||
// forge soul sandbox create <name> <s1> <s2>… — create a named sandbox with participants
|
||||
// forge soul sandbox list — list all sandboxes
|
||||
// forge soul sandbox join <id> <slug> — add a soul to an existing sandbox
|
||||
// forge soul sandbox close <id> — close sandbox and write record
|
||||
// forge soul sandbox status <id> — show sandbox state
|
||||
//
|
||||
// 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("[soul] error: could not write plist to " + plist_file)
|
||||
return ""
|
||||
}
|
||||
println("[soul] 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
|
||||
}
|
||||
|
||||
// ── soul install ─────────────────────────────────────────────────────────────
|
||||
|
||||
// soul_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 soul_install_one(slug: String, port: String, engram_url: String, subject: String) -> String {
|
||||
println("[soul] 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("[soul] 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("[soul] launchctl load: " + load_out)
|
||||
}
|
||||
|
||||
println("[soul] loaded: " + plist_label(slug))
|
||||
log_event("soul_install", subject, "port=" + port + " plist=" + pfile)
|
||||
return pfile
|
||||
}
|
||||
|
||||
fn soul_install_main() -> String {
|
||||
let argv: [String] = args()
|
||||
// args() layout: [0]="soul" [1]="install" [2]=<slug>
|
||||
let slug: String = ""
|
||||
if len(argv) > 2 {
|
||||
let slug = get(argv, 2)
|
||||
}
|
||||
if str_eq(slug, "") {
|
||||
println("[soul] usage: forge soul install <slug>")
|
||||
println("[soul] or: forge soul install --all")
|
||||
return ""
|
||||
}
|
||||
|
||||
let reg_json: String = fs_read(FORGE_DIR + "/registry.json")
|
||||
if str_eq(reg_json, "") {
|
||||
println("[soul] 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")
|
||||
soul_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")
|
||||
soul_install_one(s, p, u, sub)
|
||||
let found = 1
|
||||
let i = i + 50 // break
|
||||
} else {
|
||||
let i = i + 1
|
||||
}
|
||||
}
|
||||
}
|
||||
if found == 0 {
|
||||
println("[soul] error: slug '" + slug + "' not found in registry.json")
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
// ── soul start / stop ────────────────────────────────────────────────────────
|
||||
|
||||
fn soul_start_main() -> String {
|
||||
let argv: [String] = args()
|
||||
// args() layout: [0]="soul" [1]="start" [2]=<slug>
|
||||
let slug: String = ""
|
||||
if len(argv) > 2 {
|
||||
let slug = get(argv, 2)
|
||||
}
|
||||
if str_eq(slug, "") {
|
||||
println("[soul] usage: forge soul start <slug>")
|
||||
return ""
|
||||
}
|
||||
let out: String = launchctl_kickstart(slug)
|
||||
println("[soul] start " + slug + ": " + out)
|
||||
return out
|
||||
}
|
||||
|
||||
fn soul_stop_main() -> String {
|
||||
let argv: [String] = args()
|
||||
// args() layout: [0]="soul" [1]="stop" [2]=<slug>
|
||||
let slug: String = ""
|
||||
if len(argv) > 2 {
|
||||
let slug = get(argv, 2)
|
||||
}
|
||||
if str_eq(slug, "") {
|
||||
println("[soul] usage: forge soul stop <slug>")
|
||||
return ""
|
||||
}
|
||||
let out: String = launchctl_stop(slug)
|
||||
println("[soul] stop " + slug + ": " + out)
|
||||
return out
|
||||
}
|
||||
|
||||
// ── soul status ───────────────────────────────────────────────────────────────
|
||||
|
||||
fn soul_status_main() -> String {
|
||||
let reg_json: String = fs_read(FORGE_DIR + "/registry.json")
|
||||
if str_eq(reg_json, "") {
|
||||
println("[soul] error: could not read registry.json")
|
||||
return ""
|
||||
}
|
||||
|
||||
println("[soul] 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("[soul] up=" + int_to_str(up) + " down=" + int_to_str(down))
|
||||
return ""
|
||||
}
|
||||
|
||||
// ── soul 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 soul_wire_main() -> String {
|
||||
let reg_json: String = fs_read(FORGE_DIR + "/registry.json")
|
||||
if str_eq(reg_json, "") {
|
||||
println("[soul] error: could not read registry.json")
|
||||
return ""
|
||||
}
|
||||
|
||||
println("[soul] 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("[soul] wire complete: registered=" + int_to_str(registered) + " failed=" + int_to_str(failed))
|
||||
return ""
|
||||
}
|
||||
|
||||
// ── Sandbox helpers ──────────────────────────────────────────────────────────
|
||||
//
|
||||
// Sandboxes are bounded collaboration spaces for a subset of DHARMA souls.
|
||||
// Each sandbox is persisted as FORGE_DIR/sandboxes/<id>.json.
|
||||
//
|
||||
// JSON structure:
|
||||
// { "id": "sb-<uuid>", "name": "...", "created_at": <ts>,
|
||||
// "status": "active"|"closed", "participants": [...],
|
||||
// "topic": "...", "working_memory": [], "record": [] }
|
||||
|
||||
let FORGE_SANDBOXES_DIR: String = FORGE_DIR + "/sandboxes"
|
||||
|
||||
// sandbox_path — full path to a sandbox JSON file.
|
||||
fn sandbox_path(id: String) -> String {
|
||||
FORGE_SANDBOXES_DIR + "/" + id + ".json"
|
||||
}
|
||||
|
||||
// sandbox_ensure_dir — create sandboxes dir if absent.
|
||||
fn sandbox_ensure_dir() -> Void {
|
||||
if !fs_exists(FORGE_SANDBOXES_DIR) { fs_mkdir(FORGE_SANDBOXES_DIR) }
|
||||
}
|
||||
|
||||
// sandbox_new_json — build a fresh sandbox JSON string.
|
||||
fn sandbox_new_json(id: String, name: String, topic: String, participants_json: String) -> String {
|
||||
let ts: Int = unix_timestamp()
|
||||
"{\"id\":\"" + id + "\",\"name\":\"" + str_escape_json(name) +
|
||||
"\",\"created_at\":" + int_to_str(ts) +
|
||||
",\"status\":\"active\"" +
|
||||
",\"participants\":" + participants_json +
|
||||
",\"topic\":\"" + str_escape_json(topic) + "\"" +
|
||||
",\"working_memory\":[]" +
|
||||
",\"record\":[]}"
|
||||
}
|
||||
|
||||
// sandbox_read — read and return a sandbox JSON, or "" if not found.
|
||||
fn sandbox_read(id: String) -> String {
|
||||
let path: String = sandbox_path(id)
|
||||
if !fs_exists(path) { return "" }
|
||||
fs_read(path)
|
||||
}
|
||||
|
||||
// sandbox_write — persist a sandbox JSON.
|
||||
fn sandbox_write(id: String, json: String) -> Int {
|
||||
sandbox_ensure_dir()
|
||||
fs_write(sandbox_path(id), json)
|
||||
}
|
||||
|
||||
// sandbox_build_participants_json — build a JSON array string from a list of slugs.
|
||||
// Reads up to 20 slugs from args starting at position `start`.
|
||||
fn sandbox_build_participants_json(argv: [String], start: Int) -> String {
|
||||
let arr: String = "["
|
||||
let first: Int = 1
|
||||
let i: Int = start
|
||||
while i < len(argv) {
|
||||
let slug: String = get(argv, i)
|
||||
if !str_eq(slug, "") {
|
||||
if first == 0 {
|
||||
let arr = arr + ","
|
||||
}
|
||||
let arr = arr + "\"" + str_escape_json(slug) + "\""
|
||||
let first = 0
|
||||
}
|
||||
let i = i + 1
|
||||
}
|
||||
arr + "]"
|
||||
}
|
||||
|
||||
// sandbox_participants_count — count participants in a sandbox JSON.
|
||||
// NOTE: participants is a string array — must use json_get(), not json_get_string().
|
||||
fn sandbox_participants_count(sandbox_json: String) -> Int {
|
||||
let n: Int = 0
|
||||
let i: Int = 0
|
||||
while i < 50 {
|
||||
let p: String = json_get(sandbox_json, "participants." + int_to_str(i))
|
||||
if str_eq(p, "") {
|
||||
return n
|
||||
}
|
||||
let n = n + 1
|
||||
let i = i + 1
|
||||
}
|
||||
return n
|
||||
}
|
||||
|
||||
// sandbox_list_ids — return a newline-separated list of sandbox IDs by scanning sandboxes dir.
|
||||
// We use exec + ls because El has no readdir builtin.
|
||||
fn sandbox_list_ids() -> String {
|
||||
sandbox_ensure_dir()
|
||||
let out: String = exec("ls " + FORGE_SANDBOXES_DIR + " 2>/dev/null")
|
||||
return str_trim(out)
|
||||
}
|
||||
|
||||
// ── forge soul sandbox create ────────────────────────────────────────────────
|
||||
|
||||
fn soul_sandbox_create_main() -> String {
|
||||
// args layout: [0]="soul" [1]="sandbox" [2]="create" [3]=<name> [4..]=<slug>...
|
||||
let argv: [String] = args()
|
||||
let name: String = ""
|
||||
if len(argv) > 3 {
|
||||
let name = get(argv, 3)
|
||||
}
|
||||
if str_eq(name, "") {
|
||||
println("[sandbox] usage: forge soul sandbox create <name> [slug1 slug2 ...]")
|
||||
return ""
|
||||
}
|
||||
|
||||
let participants_json: String = sandbox_build_participants_json(argv, 4)
|
||||
|
||||
// Derive topic from name (placeholder; can be overridden later via join/edit)
|
||||
let topic: String = name
|
||||
|
||||
let id: String = "sb-" + uuid_v4()
|
||||
let json: String = sandbox_new_json(id, name, topic, participants_json)
|
||||
sandbox_ensure_dir()
|
||||
let ok: Int = sandbox_write(id, json)
|
||||
if ok == 0 {
|
||||
println("[sandbox] error: could not write sandbox file")
|
||||
return ""
|
||||
}
|
||||
|
||||
println("[sandbox] created: " + id)
|
||||
println("[sandbox] name: " + name)
|
||||
println("[sandbox] file: " + sandbox_path(id))
|
||||
log_event("sandbox_create", name, "id=" + id + " participants=" + participants_json)
|
||||
return id
|
||||
}
|
||||
|
||||
// ── forge soul sandbox list ──────────────────────────────────────────────────
|
||||
|
||||
fn soul_sandbox_list_main() -> String {
|
||||
sandbox_ensure_dir()
|
||||
let listing: String = sandbox_list_ids()
|
||||
if str_eq(listing, "") {
|
||||
println("[sandbox] no sandboxes found")
|
||||
return ""
|
||||
}
|
||||
|
||||
println("[sandbox] active sandboxes:")
|
||||
println("")
|
||||
|
||||
// Each line is a filename like "sb-<uuid>.json"
|
||||
// We split by newline by iterating: exec ls outputs one file per line
|
||||
// We use a simple approach: re-read each file by constructing the path
|
||||
let files_out: String = exec("ls " + FORGE_SANDBOXES_DIR + "/*.json 2>/dev/null")
|
||||
let files: String = str_trim(files_out)
|
||||
if str_eq(files, "") {
|
||||
println("[sandbox] no sandboxes found")
|
||||
return ""
|
||||
}
|
||||
|
||||
// Parse line-by-line via exec + while loop using index
|
||||
// El has no split(), so we iterate using exec to list files individually
|
||||
let count: Int = 0
|
||||
let i: Int = 0
|
||||
// We use a trick: exec "ls -1" and parse each file
|
||||
// Since El has no string split, we re-use the file listing via a numbered approach
|
||||
let num_files_str: String = str_trim(exec("ls " + FORGE_SANDBOXES_DIR + "/*.json 2>/dev/null | wc -l"))
|
||||
let num_files: Int = str_to_int(num_files_str)
|
||||
|
||||
while i < num_files {
|
||||
let file_path_raw: String = str_trim(exec("ls " + FORGE_SANDBOXES_DIR + "/*.json 2>/dev/null | sed -n '" + int_to_str(i + 1) + "p'"))
|
||||
if !str_eq(file_path_raw, "") {
|
||||
let sb_json: String = fs_read(file_path_raw)
|
||||
if !str_eq(sb_json, "") {
|
||||
let sb_id: String = json_get_string(sb_json, "id")
|
||||
let sb_name: String = json_get_string(sb_json, "name")
|
||||
let sb_status: String = json_get_string(sb_json, "status")
|
||||
let sb_ts: Int = json_get_int(sb_json, "created_at")
|
||||
let n_parts: Int = sandbox_participants_count(sb_json)
|
||||
println(" [" + sb_status + "] " + sb_id + " " + sb_name + " (" + int_to_str(n_parts) + " participants) created=" + int_to_str(sb_ts))
|
||||
let count = count + 1
|
||||
}
|
||||
}
|
||||
let i = i + 1
|
||||
}
|
||||
|
||||
if count == 0 {
|
||||
println("[sandbox] no sandboxes found")
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
// ── forge soul sandbox join ──────────────────────────────────────────────────
|
||||
|
||||
fn soul_sandbox_join_main() -> String {
|
||||
// args: [0]="soul" [1]="sandbox" [2]="join" [3]=<id> [4]=<slug>
|
||||
let argv: [String] = args()
|
||||
let id: String = ""
|
||||
let slug: String = ""
|
||||
if len(argv) > 3 { let id = get(argv, 3) }
|
||||
if len(argv) > 4 { let slug = get(argv, 4) }
|
||||
if str_eq(id, "") || str_eq(slug, "") {
|
||||
println("[sandbox] usage: forge soul sandbox join <sandbox-id> <slug>")
|
||||
return ""
|
||||
}
|
||||
|
||||
let sb_json: String = sandbox_read(id)
|
||||
if str_eq(sb_json, "") {
|
||||
println("[sandbox] error: sandbox not found: " + id)
|
||||
return ""
|
||||
}
|
||||
|
||||
let status: String = json_get_string(sb_json, "status")
|
||||
if str_eq(status, "closed") {
|
||||
println("[sandbox] error: sandbox is closed: " + id)
|
||||
return ""
|
||||
}
|
||||
|
||||
// Check if slug already present
|
||||
let already: Int = 0
|
||||
let i: Int = 0
|
||||
while i < 50 {
|
||||
let p: String = json_get(sb_json, "participants." + int_to_str(i))
|
||||
if str_eq(p, "") {
|
||||
let i = i + 50 // break
|
||||
} else {
|
||||
if str_eq(p, slug) {
|
||||
let already = 1
|
||||
let i = i + 50 // break
|
||||
} else {
|
||||
let i = i + 1
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if already == 1 {
|
||||
println("[sandbox] " + slug + " is already a participant in " + id)
|
||||
return ""
|
||||
}
|
||||
|
||||
// Build new participants array by appending
|
||||
let n: Int = sandbox_participants_count(sb_json)
|
||||
let new_parts: String = "["
|
||||
let j: Int = 0
|
||||
while j < n {
|
||||
let p: String = json_get(sb_json, "participants." + int_to_str(j))
|
||||
if j > 0 { let new_parts = new_parts + "," }
|
||||
let new_parts = new_parts + "\"" + str_escape_json(p) + "\""
|
||||
let j = j + 1
|
||||
}
|
||||
if n > 0 { let new_parts = new_parts + "," }
|
||||
let new_parts = new_parts + "\"" + str_escape_json(slug) + "\""
|
||||
let new_parts = new_parts + "]"
|
||||
|
||||
// Reconstruct sandbox JSON with updated participants
|
||||
let sb_id: String = json_get_string(sb_json, "id")
|
||||
let sb_name: String = json_get_string(sb_json, "name")
|
||||
let sb_ts: Int = json_get_int(sb_json, "created_at")
|
||||
let sb_topic: String = json_get_string(sb_json, "topic")
|
||||
let updated: String = "{\"id\":\"" + str_escape_json(sb_id) +
|
||||
"\",\"name\":\"" + str_escape_json(sb_name) +
|
||||
"\",\"created_at\":" + int_to_str(sb_ts) +
|
||||
",\"status\":\"active\"" +
|
||||
",\"participants\":" + new_parts +
|
||||
",\"topic\":\"" + str_escape_json(sb_topic) + "\"" +
|
||||
",\"working_memory\":[]" +
|
||||
",\"record\":[]}"
|
||||
sandbox_write(id, updated)
|
||||
|
||||
println("[sandbox] " + slug + " joined sandbox " + id)
|
||||
log_event("sandbox_join", sb_name, "id=" + id + " slug=" + slug)
|
||||
return ""
|
||||
}
|
||||
|
||||
// ── forge soul sandbox close ─────────────────────────────────────────────────
|
||||
|
||||
fn soul_sandbox_close_main() -> String {
|
||||
// args: [0]="soul" [1]="sandbox" [2]="close" [3]=<id>
|
||||
let argv: [String] = args()
|
||||
let id: String = ""
|
||||
if len(argv) > 3 { let id = get(argv, 3) }
|
||||
if str_eq(id, "") {
|
||||
println("[sandbox] usage: forge soul sandbox close <sandbox-id>")
|
||||
return ""
|
||||
}
|
||||
|
||||
let sb_json: String = sandbox_read(id)
|
||||
if str_eq(sb_json, "") {
|
||||
println("[sandbox] error: sandbox not found: " + id)
|
||||
return ""
|
||||
}
|
||||
|
||||
let status: String = json_get_string(sb_json, "status")
|
||||
if str_eq(status, "closed") {
|
||||
println("[sandbox] sandbox already closed: " + id)
|
||||
return ""
|
||||
}
|
||||
|
||||
let sb_id: String = json_get_string(sb_json, "id")
|
||||
let sb_name: String = json_get_string(sb_json, "name")
|
||||
let sb_ts: Int = json_get_int(sb_json, "created_at")
|
||||
let sb_topic: String = json_get_string(sb_json, "topic")
|
||||
let close_ts: Int = unix_timestamp()
|
||||
|
||||
// Rebuild participants array
|
||||
let n: Int = sandbox_participants_count(sb_json)
|
||||
let parts_json: String = "["
|
||||
let j: Int = 0
|
||||
while j < n {
|
||||
let p: String = json_get(sb_json, "participants." + int_to_str(j))
|
||||
if j > 0 { let parts_json = parts_json + "," }
|
||||
let parts_json = parts_json + "\"" + str_escape_json(p) + "\""
|
||||
let j = j + 1
|
||||
}
|
||||
let parts_json = parts_json + "]"
|
||||
|
||||
// Write closed record with closed_at timestamp
|
||||
let closed: String = "{\"id\":\"" + str_escape_json(sb_id) +
|
||||
"\",\"name\":\"" + str_escape_json(sb_name) +
|
||||
"\",\"created_at\":" + int_to_str(sb_ts) +
|
||||
",\"closed_at\":" + int_to_str(close_ts) +
|
||||
",\"status\":\"closed\"" +
|
||||
",\"participants\":" + parts_json +
|
||||
",\"topic\":\"" + str_escape_json(sb_topic) + "\"" +
|
||||
",\"working_memory\":[]" +
|
||||
",\"record\":[{\"ts\":" + int_to_str(close_ts) + ",\"event\":\"sandbox_closed\",\"by\":\"forge\"}]}"
|
||||
sandbox_write(id, closed)
|
||||
|
||||
println("[sandbox] closed: " + id + " (" + sb_name + ")")
|
||||
println("[sandbox] record: " + sandbox_path(id))
|
||||
log_event("sandbox_close", sb_name, "id=" + id + " closed_at=" + int_to_str(close_ts))
|
||||
return ""
|
||||
}
|
||||
|
||||
// ── forge soul sandbox status ────────────────────────────────────────────────
|
||||
|
||||
fn soul_sandbox_status_main() -> String {
|
||||
// args: [0]="soul" [1]="sandbox" [2]="status" [3]=<id>
|
||||
let argv: [String] = args()
|
||||
let id: String = ""
|
||||
if len(argv) > 3 { let id = get(argv, 3) }
|
||||
if str_eq(id, "") {
|
||||
println("[sandbox] usage: forge soul sandbox status <sandbox-id>")
|
||||
return ""
|
||||
}
|
||||
|
||||
let sb_json: String = sandbox_read(id)
|
||||
if str_eq(sb_json, "") {
|
||||
println("[sandbox] error: sandbox not found: " + id)
|
||||
return ""
|
||||
}
|
||||
|
||||
let sb_id: String = json_get_string(sb_json, "id")
|
||||
let sb_name: String = json_get_string(sb_json, "name")
|
||||
let sb_status: String = json_get_string(sb_json, "status")
|
||||
let sb_ts: Int = json_get_int(sb_json, "created_at")
|
||||
let sb_topic: String = json_get_string(sb_json, "topic")
|
||||
let n: Int = sandbox_participants_count(sb_json)
|
||||
|
||||
println("[sandbox] " + sb_id)
|
||||
println(" name: " + sb_name)
|
||||
println(" status: " + sb_status)
|
||||
println(" topic: " + sb_topic)
|
||||
println(" created: " + int_to_str(sb_ts))
|
||||
println(" participants (" + int_to_str(n) + "):")
|
||||
let k: Int = 0
|
||||
while k < n {
|
||||
let p: String = json_get(sb_json, "participants." + int_to_str(k))
|
||||
println(" - " + p)
|
||||
let k = k + 1
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
// ── forge soul sandbox dispatch ──────────────────────────────────────────────
|
||||
|
||||
fn soul_sandbox_main() -> String {
|
||||
// args: [0]="soul" [1]="sandbox" [2]=<subcmd> ...
|
||||
let argv: [String] = args()
|
||||
let subcmd: String = ""
|
||||
if len(argv) > 2 {
|
||||
let subcmd = get(argv, 2)
|
||||
}
|
||||
if str_eq(subcmd, "create") {
|
||||
soul_sandbox_create_main()
|
||||
} else {
|
||||
if str_eq(subcmd, "list") {
|
||||
soul_sandbox_list_main()
|
||||
} else {
|
||||
if str_eq(subcmd, "join") {
|
||||
soul_sandbox_join_main()
|
||||
} else {
|
||||
if str_eq(subcmd, "close") {
|
||||
soul_sandbox_close_main()
|
||||
} else {
|
||||
if str_eq(subcmd, "status") {
|
||||
soul_sandbox_status_main()
|
||||
} else {
|
||||
println("[sandbox] usage: forge soul sandbox <create|list|join|close|status> [args]")
|
||||
println("")
|
||||
println(" forge soul sandbox create <name> [slug1 slug2 ...] — create sandbox")
|
||||
println(" forge soul sandbox list — list all sandboxes")
|
||||
println(" forge soul sandbox join <id> <slug> — add soul to sandbox")
|
||||
println(" forge soul sandbox close <id> — close and record sandbox")
|
||||
println(" forge soul sandbox status <id> — show sandbox state")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return ""
|
||||
}
|
||||
|
||||
// ── soul_main — dispatch ─────────────────────────────────────────────────────
|
||||
//
|
||||
// args() layout when invoked as: forge soul <subcmd> [slug]
|
||||
// args()[0] = "soul"
|
||||
// args()[1] = <subcmd> e.g. "install"
|
||||
// args()[2] = [slug] e.g. "bobby-anderson"
|
||||
|
||||
fn soul_main() -> String {
|
||||
let argv: [String] = args()
|
||||
let subcmd: String = ""
|
||||
if len(argv) > 1 {
|
||||
let subcmd = get(argv, 1)
|
||||
}
|
||||
|
||||
if str_eq(subcmd, "install") {
|
||||
soul_install_main()
|
||||
} else {
|
||||
if str_eq(subcmd, "start") {
|
||||
soul_start_main()
|
||||
} else {
|
||||
if str_eq(subcmd, "stop") {
|
||||
soul_stop_main()
|
||||
} else {
|
||||
if str_eq(subcmd, "status") {
|
||||
soul_status_main()
|
||||
} else {
|
||||
if str_eq(subcmd, "wire") {
|
||||
soul_wire_main()
|
||||
} else {
|
||||
if str_eq(subcmd, "sandbox") {
|
||||
soul_sandbox_main()
|
||||
} else {
|
||||
println("[soul] usage: forge soul <install|start|stop|status|wire|sandbox> [slug]")
|
||||
println("")
|
||||
println(" forge soul install <slug> — write launchd plist, load soul as resident")
|
||||
println(" forge soul install --all — install all souls from registry")
|
||||
println(" forge soul start <slug> — kickstart a loaded soul")
|
||||
println(" forge soul stop <slug> — stop a running soul")
|
||||
println(" forge soul status — health check all souls")
|
||||
println(" forge soul wire — register all souls as Engram peers")
|
||||
println(" forge soul sandbox <subcmd> — sandbox management (create|list|join|close|status)")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return ""
|
||||
}
|
||||
Reference in New Issue
Block a user