@gajae-gateway/cli 0.1.3 → 0.1.5

package/src/migrate/source-fs.ts

@@ -0,0 +1,126 @@
+import { lstat, readdir, readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join, relative } from "node:path";
+
+/**
+ * Read-only access to a source tree. Every read is recorded, so whatever the
+ * readers did not consume can be reported as unmapped instead of vanishing.
+ * Nothing here opens a file for writing.
+ */
+export class SourceTree {
+	readonly root: string;
+	readonly #consumed = new Set<string>();
+
+	constructor(root: string) {
+		this.root = root;
+	}
+
+	/** Relative display path for a source file, `~`-free and stable across hosts. */
+	rel(path: string): string {
+		const inside = relative(this.root, path);
+		return inside.startsWith("..") ? path : inside || ".";
+	}
+
+	consume(path: string): void {
+		this.#consumed.add(path);
+	}
+
+	isConsumed(path: string): boolean {
+		for (const consumed of this.#consumed)
+			if (path === consumed || path.startsWith(`${consumed}/`) || consumed.startsWith(`${path}/`)) return true;
+		return false;
+	}
+
+	/** Consumed exactly, or entirely beneath a consumed directory. */
+	isFullyConsumed(path: string): boolean {
+		for (const consumed of this.#consumed) if (path === consumed || path.startsWith(`${consumed}/`)) return true;
+		return false;
+	}
+
+	async text(path: string): Promise<string | undefined> {
+		const info = await regularFile(path);
+		if (!info) return undefined;
+		this.consume(path);
+		return readFile(path, "utf8");
+	}
+
+	async bytes(path: string): Promise<Uint8Array | undefined> {
+		const info = await regularFile(path);
+		if (!info) return undefined;
+		this.consume(path);
+		return new Uint8Array(await readFile(path));
+	}
+}
+
+/** Stat without following symlinks; only a plain regular file qualifies. */
+export async function regularFile(path: string): Promise<{ mtime: Date } | undefined> {
+	try {
+		const info = await lstat(path);
+		return info.isFile() ? { mtime: info.mtime } : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+export async function isDirectory(path: string): Promise<boolean> {
+	try {
+		return (await lstat(path)).isDirectory();
+	} catch {
+		return false;
+	}
+}
+
+export async function entries(path: string): Promise<string[]> {
+	try {
+		return (await readdir(path)).sort();
+	} catch {
+		return [];
+	}
+}
+
+/** Every regular file under `dir`, relative to it, skipping symlinks (they may point anywhere). */
+export async function walkFiles(dir: string, prefix = ""): Promise<string[]> {
+	const out: string[] = [];
+	for (const name of await entries(dir)) {
+		const full = join(dir, name);
+		const info = await lstat(full).catch(() => undefined);
+		if (!info) continue;
+		if (info.isDirectory()) out.push(...(await walkFiles(full, join(prefix, name))));
+		else if (info.isFile()) out.push(join(prefix, name));
+	}
+	return out;
+}
+
+/** Minimal dotenv reader: KEY=VALUE lines, optional `export`, single/double quotes, `#` comments. */
+export function parseDotenv(text: string): Map<string, string> {
+	const values = new Map<string, string>();
+	for (const rawLine of text.split(/\r?\n/)) {
+		const line = rawLine.trim();
+		if (!line || line.startsWith("#")) continue;
+		const match = /^(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/.exec(line);
+		if (!match) continue;
+		let value = match[2] ?? "";
+		const quote = value[0];
+		if ((quote === '"' || quote === "'") && value.lastIndexOf(quote) > 0)
+			value = value.slice(1, value.lastIndexOf(quote));
+		else value = value.replace(/\s+#.*$/, "").trim();
+		values.set(match[1] as string, value);
+	}
+	return values;
+}
+
+export function expandHome(path: string): string {
+	return path === "~" ? homedir() : path.startsWith("~/") ? join(homedir(), path.slice(2)) : path;
+}
+
+export function isRecord(value: unknown): value is Record<string, unknown> {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+/** A comma-separated string or a list, as both Hermes and OpenClaw accept. */
+export function stringList(value: unknown): string[] {
+	const items = Array.isArray(value) ? value : typeof value === "string" ? value.split(",") : [];
+	return items.map((item) => String(item).trim()).filter(Boolean);
+}
+
+export const DATED_FILE = /^(\d{4})-(\d{2})-(\d{2})\.md$/;

package/src/migrate.ts

@@ -0,0 +1,158 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { detectHermes, readHermes } from "./migrate/hermes";
+import { detectOpenClaw, readOpenClaw } from "./migrate/openclaw";
+import {
+	emitChannels,
+	emitImportedAxis,
+	emitMonitors,
+	emptyChannelPlan,
+	type MigrationSource,
+	type SourceExtract,
+} from "./migrate/plan";
+import { expandHome, SourceTree } from "./migrate/source-fs";
+
+export interface MigrateOptions {
+	source?: string;
+	target?: string;
+	dryRun?: boolean;
+}
+
+/**
+ * Main migration entry point. Detects the source type (Hermes or OpenClaw),
+ * reads its configuration, and writes the gajae-way-compatible output.
+ */
+export async function migrate(options: MigrateOptions): Promise<void> {
+	const sourceRoot = expandHome(options.source ?? ".");
+	const targetHome = expandHome(options.target ?? `${process.env.HOME ?? "~"}/.gajaeway`);
+
+	// Detect source type
+	let sourceType: MigrationSource | undefined;
+	if (await detectHermes(sourceRoot)) {
+		sourceType = "hermes";
+	} else if (await detectOpenClaw(sourceRoot)) {
+		sourceType = "openclaw";
+	} else {
+		throw new Error(
+			`No Hermes or OpenClaw configuration detected at ${sourceRoot}. Expected .hermes.config.json or config.json`,
+		);
+	}
+
+	console.log(`Detected ${sourceType} configuration at ${sourceRoot}`);
+
+	// Create source tree for tracking consumed files
+	const tree = new SourceTree(sourceRoot);
+
+	// Read source configuration
+	let extract: SourceExtract;
+	if (sourceType === "hermes") {
+		extract = await readHermes(tree, targetHome);
+	} else {
+		extract = await readOpenClaw(tree, targetHome);
+	}
+
+	// Report warnings
+	for (const warning of extract.warnings) {
+		console.warn(`Warning: ${warning}`);
+	}
+
+	// Report unmapped entries
+	if (extract.unmapped.length > 0) {
+		console.log("\nUnmapped entries (these will not be migrated):");
+		const byCategory = new Map<string, typeof extract.unmapped>();
+		for (const entry of extract.unmapped) {
+			if (!byCategory.has(entry.category)) {
+				byCategory.set(entry.category, []);
+			}
+			const cat = byCategory.get(entry.category);
+			if (cat) {
+				cat.push(entry);
+			}
+		}
+
+		for (const [category, entries] of byCategory) {
+			console.log(`  ${category}:`);
+			for (const entry of entries) {
+				console.log(`    - ${entry.source}: ${entry.reason}`);
+			}
+		}
+	}
+
+	// Report inventory
+	if (extract.inventory.persona.length > 0 || extract.inventory.schedules.length > 0) {
+		console.log("\nMigration summary:");
+		console.log(`  Personas: ${extract.inventory.persona.length}`);
+		console.log(`  Schedules: ${extract.inventory.schedules.length}`);
+		console.log(`  Memory entries: ${extract.inventory.memory.length}`);
+		console.log(`  Skills: ${extract.inventory.skills.length}`);
+		console.log(`  Channels: ${extract.inventory.channels.length}`);
+	}
+
+	if (options.dryRun) {
+		console.log("\n[DRY RUN] Output would be written to:");
+		for (const file of extract.files) {
+			console.log(`  ${file.target} (${file.category})`);
+		}
+		return;
+	}
+
+	// Write files
+	await mkdir(targetHome, { recursive: true });
+
+	// Create channel plan and emit configurations
+	const channels = emptyChannelPlan();
+	emitChannels(extract, channels, targetHome, sourceType);
+	emitMonitors(extract);
+	emitImportedAxis(extract);
+
+	// Write source files
+	for (const file of extract.files) {
+		const filePath = join(targetHome, file.target);
+		await mkdir(join(filePath, ".."), { recursive: true });
+		await writeFile(filePath, file.content);
+	}
+
+	// Write merged JSON files
+	for (const merge of extract.merges) {
+		const filePath = join(targetHome, merge.target);
+		await mkdir(join(filePath, ".."), { recursive: true });
+		let existing: Record<string, unknown> | undefined;
+		try {
+			const text = await readFile(filePath, "utf-8");
+			existing = JSON.parse(text) as Record<string, unknown>;
+		} catch {
+			// File doesn't exist or is not valid JSON, start fresh
+		}
+		const merged = merge.merge(existing);
+		await writeFile(filePath, JSON.stringify(merged, null, 2));
+	}
+
+	console.log(`\nMigration complete. Output written to ${targetHome}`);
+}
+
+/**
+ * Parse command-line arguments for the migrate command.
+ */
+export function parseMigrateArgs(args: readonly string[]): MigrateOptions {
+	const options: MigrateOptions = {};
+
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+
+		if (arg === "--source" && args[i + 1]) {
+			options.source = args[++i];
+		} else if (arg === "--target" && args[i + 1]) {
+			options.target = args[++i];
+		} else if (arg === "--dry-run") {
+			options.dryRun = true;
+		} else if (arg.startsWith("--")) {
+			throw new Error(`Unknown option: ${arg}`);
+		} else if (!options.source) {
+			options.source = arg;
+		} else {
+			throw new Error(`Unexpected argument: ${arg}`);
+		}
+	}
+
+	return options;
+}

package/src/restart-stack.ts

@@ -215,9 +215,17 @@ function defaultIsServiceInstalled(options: {
 	};
 }
 
-function floorSecond(ms: number): number {
-	return Math.floor(ms / 1_000) * 1_000;
+/**
+ * `ps -o lstart` is whole seconds, and on Linux it is derived from the boot
+ * time plus clock ticks, so it can read up to one second EARLY. Measured on
+ * gaebal-gajae 2026-09-30: systemd logged `Started` at 10:55:50.170 while
+ * `ps` reported 10:55:49, and the freshly restarted gateway was judged stale,
+ * aborting the rest of the stack. The bound is floored and allowed that second.
+ */
+function psStartBound(ms: number): number {
+	return Math.floor(ms / 1_000) * 1_000 - PS_START_SKEW_MS;
 }
+const PS_START_SKEW_MS = 1_000;
 
 /**
  * Runs the ordered restart, verifying each service before the next command,
@@ -302,8 +310,7 @@ export async function runRestartStack(options: RunRestartOptions): Promise<Resta
 				step.processStartedAt = new Date(running.startedAt).toISOString();
 				step.binary = running.binary;
 				step.binaryModifiedAt = new Date(binaryModifiedAt).toISOString();
-				// `ps` has one-second resolution, so the bound is floored to match.
-				if (running.startedAt >= floorSecond(Math.max(binaryModifiedAt, since))) {
+				if (running.startedAt >= psStartBound(Math.max(binaryModifiedAt, since))) {
 					step.result = "ok";
 					delete step.detail;
 					return;

package/src/services.ts

@@ -220,11 +220,14 @@ export function renderSystemdUnit(spec: ServiceSpec, binDir: string, home: strin
 		unitEnvironment("PATH", path),
 		"Restart=always",
 		"RestartSec=2",
-		// Only the gateway: GJC daemon and session hosts share the gateway cgroup,
-		// so the default control-group kill would take unrelated sessions with it.
-		// The gateway exits on its own inside 25s (SHUTDOWN_DEADLINE_MS in the
-		// gateway main); the unit's stop window is pinned so that ceiling always fits.
-		...(spec.dependsOnGateway ? [] : ["KillMode=process", "TimeoutStopSec=30s"]),
+		// Only the gateway: SIGTERM its main process for an ordered shutdown, then
+		// kill whatever is left in its cgroup so no child outlives the unit and
+		// gets re-adopted by the next start (#183). The gateway exits on its own
+		// inside 25s (SHUTDOWN_DEADLINE_MS in the gateway main); the unit's stop
+		// window is pinned so that ceiling always fits (#225). The gateway moves a GJC broker
+		// it autostarted into a scope of its own, so this never reaches the shared
+		// broker or its session hosts.
+		...(spec.dependsOnGateway ? [] : ["KillMode=mixed", "TimeoutStopSec=30s"]),
 		"",
 		"[Install]",
 		// Enabling the gateway pulls the whole stack in; a dependent is never