@nextclaw/service 0.1.1

package/dist/shared/services/ui/service-remote-access.service.d.ts

@@ -0,0 +1,25 @@
+import { RequestRestartParams } from "../../types/cli.types.js";
+import { RemoteAccessHost } from "../../../commands/remote/services/remote-access-host.service.js";
+import { Config } from "@nextclaw/core";
+import { RemoteServiceModule } from "@nextclaw/remote";
+
+//#region src/shared/services/ui/service-remote-access.service.d.ts
+type ManagedServiceRestartOptions = {
+  uiPort?: number;
+  reason?: string;
+};
+declare function requestManagedServiceRestart(requestRestart: (params: RequestRestartParams) => Promise<void>, options?: ManagedServiceRestartOptions): Promise<void>;
+declare function createRemoteAccessHost(params: {
+  serviceCommands: {
+    startService: (options: {
+      uiOverrides: Record<string, unknown>;
+      open: boolean;
+    }) => Promise<void>;
+    stopService: () => Promise<void>;
+  };
+  requestRestart: (params: RequestRestartParams) => Promise<void>;
+  uiConfig: Pick<Config["ui"], "host" | "port">;
+  remoteModule: RemoteServiceModule | null;
+}): RemoteAccessHost;
+//#endregion
+export { createRemoteAccessHost, requestManagedServiceRestart };

package/dist/shared/services/ui/service-remote-access.service.js

@@ -0,0 +1,38 @@
+import { RemoteAccessHost } from "../../../commands/remote/services/remote-access-host.service.js";
+import { RemoteCommands } from "../../../commands/remote/index.js";
+import { PlatformAuthCommands } from "../../../commands/platform-auth/services/platform-auth-commands.service.js";
+import "../../../commands/platform-auth/index.js";
+//#region src/shared/services/ui/service-remote-access.service.ts
+function requestManagedServiceRestart(requestRestart, options = {}) {
+	const uiPort = typeof options.uiPort === "number" && Number.isFinite(options.uiPort) ? Math.floor(options.uiPort) : void 0;
+	return requestRestart({
+		reason: options.reason?.trim() || "remote access service restart",
+		manualMessage: uiPort ? `Restart the managed service to restore the UI on port ${uiPort}.` : "Restart the managed service to restore the UI.",
+		strategy: "background-service-or-exit",
+		delayMs: 500,
+		silentOnServiceRestart: true
+	});
+}
+function createRemoteAccessHost(params) {
+	const { remoteModule, requestRestart, serviceCommands, uiConfig } = params;
+	return new RemoteAccessHost({
+		serviceCommands,
+		requestManagedServiceRestart: (options) => requestManagedServiceRestart(requestRestart, options),
+		remoteCommands: new RemoteCommands({ currentLocalOrigin: `http://127.0.0.1:${uiConfig.port}` }),
+		platformAuthCommands: new PlatformAuthCommands(),
+		currentUi: uiConfig,
+		remoteRuntimeController: remoteModule ? {
+			start: async () => {
+				remoteModule?.start();
+			},
+			stop: async () => {
+				await remoteModule?.stop();
+			},
+			restart: async () => {
+				await remoteModule?.restart();
+			}
+		} : null
+	});
+}
+//#endregion
+export { createRemoteAccessHost, requestManagedServiceRestart };

package/dist/shared/services/ui/ui-bridge-api.service.d.ts

@@ -0,0 +1,16 @@
+//#region src/shared/services/ui/ui-bridge-api.service.d.ts
+type UiBridgeApiMethod = "GET" | "POST" | "PUT" | "DELETE";
+declare function resolveLocalUiApiBase(): string | null;
+declare class UiBridgeApiClient {
+  private readonly apiBase;
+  private cookie;
+  constructor(apiBase: string);
+  private readonly getCookie;
+  readonly request: <T>(params: {
+    path: string;
+    method?: UiBridgeApiMethod;
+    body?: unknown;
+  }) => Promise<T>;
+}
+//#endregion
+export { UiBridgeApiClient, UiBridgeApiMethod, resolveLocalUiApiBase };

package/dist/shared/services/ui/ui-bridge-api.service.js

@@ -0,0 +1,43 @@
+import { localUiDiscoveryService } from "./local-ui-discovery.service.js";
+import { ensureUiBridgeSecret } from "@nextclaw/server";
+//#region src/shared/services/ui/ui-bridge-api.service.ts
+function resolveLocalUiApiBase() {
+	return localUiDiscoveryService.resolveApiBase();
+}
+var UiBridgeApiClient = class {
+	cookie;
+	constructor(apiBase) {
+		this.apiBase = apiBase;
+	}
+	getCookie = async () => {
+		if (this.cookie !== void 0) return this.cookie;
+		const bridgeSecret = ensureUiBridgeSecret();
+		const response = await fetch(`${this.apiBase}/api/auth/bridge`, {
+			method: "POST",
+			headers: { "x-nextclaw-ui-bridge-secret": bridgeSecret }
+		});
+		if (!response.ok) throw new Error(`bridge auth failed with status ${response.status}`);
+		const payload = await response.json();
+		if (!payload.ok) throw new Error(payload.error?.message ?? "bridge auth failed");
+		this.cookie = typeof payload.data.cookie === "string" && payload.data.cookie.trim() ? payload.data.cookie.trim() : null;
+		return this.cookie;
+	};
+	request = async (params) => {
+		const { body, method, path } = params;
+		const cookie = await this.getCookie();
+		const response = await fetch(`${this.apiBase}${path}`, {
+			method: method ?? "GET",
+			headers: {
+				...body ? { "Content-Type": "application/json" } : {},
+				...cookie ? { Cookie: cookie } : {}
+			},
+			...body ? { body: JSON.stringify(body) } : {}
+		});
+		if (!response.ok) throw new Error(`api request failed with status ${response.status}`);
+		const payload = await response.json();
+		if (!payload.ok) throw new Error(payload.error?.message ?? "api request failed");
+		return payload.data;
+	};
+};
+//#endregion
+export { UiBridgeApiClient, resolveLocalUiApiBase };

package/dist/shared/services/workspace/workspace-manager.service.d.ts

@@ -0,0 +1,19 @@
+//#region src/shared/services/workspace/workspace-manager.service.d.ts
+declare class WorkspaceManager {
+  private logo;
+  constructor(logo: string);
+  private readonly pkgRoot;
+  readonly createWorkspaceTemplates: (workspace: string, options?: {
+    force?: boolean;
+  }) => {
+    created: string[];
+  };
+  private readonly resolveTemplateDir;
+  readonly getBridgeDir: () => string;
+  private readonly resolveBridgeSource;
+  private readonly assertCommandAvailable;
+  private readonly runBridgeCommand;
+  private readonly exitWithError;
+}
+//#endregion
+export { WorkspaceManager };

package/dist/shared/services/workspace/workspace-manager.service.js

@@ -0,0 +1,135 @@
+import { findExecutableOnPath } from "../../utils/cli.utils.js";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { dirname, join, resolve } from "node:path";
+import { APP_NAME, getDataDir } from "@nextclaw/core";
+import { cpSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+//#region src/shared/services/workspace/workspace-manager.service.ts
+var WorkspaceManager = class {
+	constructor(logo) {
+		this.logo = logo;
+	}
+	pkgRoot = resolve(fileURLToPath(new URL(".", import.meta.url)), "..", "..", "..", "..", "..");
+	createWorkspaceTemplates = (workspace, options = {}) => {
+		const created = [];
+		const force = Boolean(options.force);
+		const templateDir = this.resolveTemplateDir();
+		if (!templateDir) {
+			console.warn("Warning: Template directory not found. Skipping workspace templates.");
+			return { created };
+		}
+		for (const entry of [
+			{
+				source: "AGENTS.md",
+				target: "AGENTS.md"
+			},
+			{
+				source: "SOUL.md",
+				target: "SOUL.md"
+			},
+			{
+				source: "USER.md",
+				target: "USER.md"
+			},
+			{
+				source: "IDENTITY.md",
+				target: "IDENTITY.md"
+			},
+			{
+				source: "TOOLS.md",
+				target: "TOOLS.md"
+			},
+			{
+				source: "BOOT.md",
+				target: "BOOT.md"
+			},
+			{
+				source: "BOOTSTRAP.md",
+				target: "BOOTSTRAP.md"
+			},
+			{
+				source: "MEMORY.md",
+				target: "MEMORY.md"
+			},
+			{
+				source: "memory/MEMORY.md",
+				target: "memory/MEMORY.md"
+			}
+		]) {
+			const filePath = join(workspace, entry.target);
+			if (!force && existsSync(filePath)) continue;
+			const templatePath = join(templateDir, entry.source);
+			if (!existsSync(templatePath)) {
+				console.warn(`Warning: Template file missing: ${templatePath}`);
+				continue;
+			}
+			const content = readFileSync(templatePath, "utf-8").replace(/\$\{APP_NAME\}/g, APP_NAME);
+			mkdirSync(dirname(filePath), { recursive: true });
+			writeFileSync(filePath, content);
+			created.push(entry.target);
+		}
+		const memoryDir = join(workspace, "memory");
+		if (!existsSync(memoryDir)) {
+			mkdirSync(memoryDir, { recursive: true });
+			created.push(join("memory", ""));
+		}
+		const skillsDir = join(workspace, "skills");
+		if (!existsSync(skillsDir)) {
+			mkdirSync(skillsDir, { recursive: true });
+			created.push(join("skills", ""));
+		}
+		return { created };
+	};
+	resolveTemplateDir = () => {
+		const override = process.env.NEXTCLAW_TEMPLATE_DIR?.trim();
+		if (override) return override;
+		const candidates = [join(this.pkgRoot, "templates")];
+		for (const candidate of candidates) if (existsSync(candidate)) return candidate;
+		return null;
+	};
+	getBridgeDir = () => {
+		const userBridge = join(getDataDir(), "bridge");
+		if (existsSync(join(userBridge, "dist", "index.js"))) return userBridge;
+		this.assertCommandAvailable("npm");
+		const source = this.resolveBridgeSource();
+		console.log(`${this.logo} Setting up bridge...`);
+		mkdirSync(resolve(userBridge, ".."), { recursive: true });
+		if (existsSync(userBridge)) rmSync(userBridge, {
+			recursive: true,
+			force: true
+		});
+		cpSync(source, userBridge, {
+			recursive: true,
+			filter: (src) => !src.includes("node_modules") && !src.includes("dist")
+		});
+		this.runBridgeCommand(userBridge, ["install"], "install");
+		this.runBridgeCommand(userBridge, ["run", "build"], "build");
+		console.log("✓ Bridge ready\n");
+		return userBridge;
+	};
+	resolveBridgeSource = () => {
+		const candidates = [join(this.pkgRoot, "bridge"), join(this.pkgRoot, "..", "..", "bridge")];
+		for (const candidate of candidates) if (existsSync(join(candidate, "package.json"))) return candidate;
+		return this.exitWithError(`Bridge source not found. Try reinstalling ${APP_NAME}.`);
+	};
+	assertCommandAvailable = (command) => {
+		if (findExecutableOnPath(command)) return;
+		this.exitWithError(`${command} not found. Please install Node.js >= 18.`);
+	};
+	runBridgeCommand = (cwd, args, step) => {
+		const result = spawnSync("npm", args, {
+			cwd,
+			stdio: "pipe"
+		});
+		if (result.status === 0) return;
+		const stderr = result.stderr ? String(result.stderr).slice(0, 500) : null;
+		this.exitWithError(`Bridge ${step} failed: ${result.status ?? 1}`, stderr);
+	};
+	exitWithError = (message, detail) => {
+		console.error(message);
+		if (detail) console.error(detail);
+		process.exit(1);
+	};
+};
+//#endregion
+export { WorkspaceManager };

package/dist/shared/stores/companion-runtime.store.d.ts

@@ -0,0 +1,15 @@
+//#region src/shared/stores/companion-runtime.store.d.ts
+type CompanionRuntimeState = {
+  pid: number;
+  startedAt: string;
+  baseUrl: string;
+};
+declare class CompanionRuntimeStore {
+  get path(): string;
+  readonly read: () => CompanionRuntimeState | null;
+  readonly write: (state: CompanionRuntimeState) => void;
+  readonly clear: () => void;
+}
+declare const companionRuntimeStore: CompanionRuntimeStore;
+//#endregion
+export { CompanionRuntimeState, CompanionRuntimeStore, companionRuntimeStore };

package/dist/shared/stores/companion-runtime.store.js

@@ -0,0 +1,27 @@
+import { resolve } from "node:path";
+import { getDataDir } from "@nextclaw/core";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+//#region src/shared/stores/companion-runtime.store.ts
+var CompanionRuntimeStore = class {
+	get path() {
+		return resolve(getDataDir(), "run", "companion.json");
+	}
+	read = () => {
+		if (!existsSync(this.path)) return null;
+		try {
+			return JSON.parse(readFileSync(this.path, "utf-8"));
+		} catch {
+			return null;
+		}
+	};
+	write = (state) => {
+		mkdirSync(resolve(this.path, ".."), { recursive: true });
+		writeFileSync(this.path, JSON.stringify(state, null, 2));
+	};
+	clear = () => {
+		if (existsSync(this.path)) rmSync(this.path, { force: true });
+	};
+};
+const companionRuntimeStore = new CompanionRuntimeStore();
+//#endregion
+export { CompanionRuntimeStore, companionRuntimeStore };

package/dist/shared/stores/local-ui-runtime.store.d.ts

@@ -0,0 +1,25 @@
+import { Config } from "@nextclaw/core";
+import { RemoteRuntimeState } from "@nextclaw/remote";
+
+//#region src/shared/stores/local-ui-runtime.store.d.ts
+type LocalUiRuntimeState = {
+  pid: number;
+  startedAt: string;
+  uiUrl: string;
+  apiUrl: string;
+  uiHost?: string;
+  uiPort?: number;
+  remote?: RemoteRuntimeState;
+};
+declare class LocalUiRuntimeStore {
+  get path(): string;
+  readonly read: () => LocalUiRuntimeState | null;
+  readonly write: (state: LocalUiRuntimeState) => void;
+  readonly update: (updater: (state: LocalUiRuntimeState) => LocalUiRuntimeState) => LocalUiRuntimeState | null;
+  readonly clear: () => void;
+  readonly clearIfOwnedByProcess: (pid?: number) => void;
+  readonly writeCurrentProcess: (uiConfig: Pick<Config["ui"], "host" | "port">, pid?: number) => LocalUiRuntimeState;
+}
+declare const localUiRuntimeStore: LocalUiRuntimeStore;
+//#endregion
+export { LocalUiRuntimeState, LocalUiRuntimeStore, localUiRuntimeStore };

package/dist/shared/stores/local-ui-runtime.store.js

@@ -0,0 +1,54 @@
+import { resolveUiApiBase } from "../utils/cli.utils.js";
+import { resolve } from "node:path";
+import { getDataDir } from "@nextclaw/core";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+//#region src/shared/stores/local-ui-runtime.store.ts
+var LocalUiRuntimeStore = class {
+	get path() {
+		return resolve(getDataDir(), "run", "ui-runtime.json");
+	}
+	read = () => {
+		if (!existsSync(this.path)) return null;
+		try {
+			const raw = readFileSync(this.path, "utf-8");
+			return JSON.parse(raw);
+		} catch {
+			return null;
+		}
+	};
+	write = (state) => {
+		mkdirSync(resolve(this.path, ".."), { recursive: true });
+		writeFileSync(this.path, JSON.stringify(state, null, 2));
+	};
+	update = (updater) => {
+		const current = this.read();
+		if (!current) return null;
+		const next = updater(current);
+		this.write(next);
+		return next;
+	};
+	clear = () => {
+		if (existsSync(this.path)) rmSync(this.path, { force: true });
+	};
+	clearIfOwnedByProcess = (pid = process.pid) => {
+		if (this.read()?.pid === pid) this.clear();
+	};
+	writeCurrentProcess = (uiConfig, pid = process.pid) => {
+		const existing = this.read();
+		const uiUrl = resolveUiApiBase(uiConfig.host, uiConfig.port);
+		const state = {
+			pid,
+			startedAt: existing?.pid === pid && typeof existing.startedAt === "string" ? existing.startedAt : (/* @__PURE__ */ new Date()).toISOString(),
+			uiUrl,
+			apiUrl: `${uiUrl}/api`,
+			uiHost: uiConfig.host,
+			uiPort: uiConfig.port,
+			...existing?.remote ? { remote: existing.remote } : {}
+		};
+		this.write(state);
+		return state;
+	};
+};
+const localUiRuntimeStore = new LocalUiRuntimeStore();
+//#endregion
+export { LocalUiRuntimeStore, localUiRuntimeStore };

package/dist/shared/stores/managed-service-state.store.d.ts

@@ -0,0 +1,28 @@
+import { RemoteRuntimeState } from "@nextclaw/remote";
+
+//#region src/shared/stores/managed-service-state.store.d.ts
+type ManagedServiceState = {
+  pid: number;
+  startedAt: string;
+  uiUrl: string;
+  apiUrl: string;
+  uiHost?: string;
+  uiPort?: number;
+  logPath: string;
+  startupState?: "ready" | "degraded";
+  startupLastProbeError?: string | null;
+  startupTimeoutMs?: number;
+  startupCheckedAt?: string;
+  remote?: RemoteRuntimeState;
+};
+declare class ManagedServiceStateStore {
+  get path(): string;
+  readonly read: () => ManagedServiceState | null;
+  readonly write: (state: ManagedServiceState) => void;
+  readonly update: (updater: (state: ManagedServiceState) => ManagedServiceState) => ManagedServiceState | null;
+  readonly clear: () => void;
+  readonly clearIfOwnedByProcess: (pid?: number) => void;
+}
+declare const managedServiceStateStore: ManagedServiceStateStore;
+//#endregion
+export { ManagedServiceState, ManagedServiceStateStore, managedServiceStateStore };

package/dist/shared/stores/managed-service-state.store.js

@@ -0,0 +1,38 @@
+import { resolve } from "node:path";
+import { getDataDir } from "@nextclaw/core";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+//#region src/shared/stores/managed-service-state.store.ts
+var ManagedServiceStateStore = class {
+	get path() {
+		return resolve(getDataDir(), "run", "service.json");
+	}
+	read = () => {
+		if (!existsSync(this.path)) return null;
+		try {
+			const raw = readFileSync(this.path, "utf-8");
+			return JSON.parse(raw);
+		} catch {
+			return null;
+		}
+	};
+	write = (state) => {
+		mkdirSync(resolve(this.path, ".."), { recursive: true });
+		writeFileSync(this.path, JSON.stringify(state, null, 2));
+	};
+	update = (updater) => {
+		const current = this.read();
+		if (!current) return null;
+		const next = updater(current);
+		this.write(next);
+		return next;
+	};
+	clear = () => {
+		if (existsSync(this.path)) rmSync(this.path, { force: true });
+	};
+	clearIfOwnedByProcess = (pid = process.pid) => {
+		if (this.read()?.pid === pid) this.clear();
+	};
+};
+const managedServiceStateStore = new ManagedServiceStateStore();
+//#endregion
+export { ManagedServiceStateStore, managedServiceStateStore };

package/dist/shared/stores/pending-restart.store.d.ts

@@ -0,0 +1,21 @@
+//#region src/shared/stores/pending-restart.store.d.ts
+type PendingRestartState = {
+  changedPaths: string[];
+  message: string;
+  reasons: string[];
+  requestedAt: string;
+};
+type MarkPendingRestartParams = {
+  changedPaths?: string[];
+  manualMessage: string;
+  reason: string;
+};
+declare class PendingRestartStore {
+  private state;
+  readonly read: () => PendingRestartState | null;
+  readonly mark: (params: MarkPendingRestartParams) => PendingRestartState;
+  readonly clear: () => void;
+}
+declare const pendingRestartStore: PendingRestartStore;
+//#endregion
+export { PendingRestartState, PendingRestartStore, pendingRestartStore };

package/dist/shared/stores/pending-restart.store.js

@@ -0,0 +1,35 @@
+//#region src/shared/stores/pending-restart.store.ts
+const clonePendingRestartState = (state) => {
+	if (!state) return null;
+	return {
+		changedPaths: [...state.changedPaths],
+		message: state.message,
+		reasons: [...state.reasons],
+		requestedAt: state.requestedAt
+	};
+};
+const dedupeStrings = (values) => {
+	return Array.from(new Set(values.map((value) => value.trim()).filter((value) => value.length > 0)));
+};
+var PendingRestartStore = class {
+	state = null;
+	read = () => {
+		return clonePendingRestartState(this.state);
+	};
+	mark = (params) => {
+		const nextState = {
+			changedPaths: dedupeStrings([...this.state?.changedPaths ?? [], ...params.changedPaths ?? []]),
+			message: params.manualMessage.trim() || this.state?.message || "Restart required to apply saved changes.",
+			reasons: dedupeStrings([...this.state?.reasons ?? [], params.reason]),
+			requestedAt: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		this.state = nextState;
+		return clonePendingRestartState(nextState);
+	};
+	clear = () => {
+		this.state = null;
+	};
+};
+const pendingRestartStore = new PendingRestartStore();
+//#endregion
+export { PendingRestartStore, pendingRestartStore };