nolo-cli 0.1.11 → 0.1.13

package/connector-experimental/heartbeatLoop.ts

@@ -0,0 +1,22 @@
+export type HeartbeatLoopOptions = {
+  intervalMs: number;
+  sendHeartbeat: () => Promise<void>;
+  sleep?: (ms: number) => Promise<void>;
+  signal?: AbortSignal;
+  maxBeats?: number;
+};
+
+const defaultSleep = (ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms));
+
+export async function runHeartbeatLoop(options: HeartbeatLoopOptions): Promise<void> {
+  const sleep = options.sleep ?? defaultSleep;
+  let beats = 0;
+
+  while (!options.signal?.aborted) {
+    await options.sendHeartbeat();
+    beats += 1;
+    if (options.maxBeats && beats >= options.maxBeats) return;
+    if (options.signal?.aborted) return;
+    await sleep(options.intervalMs);
+  }
+}

package/connector-experimental/machineInfo.ts

@@ -0,0 +1,46 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { arch, hostname, homedir, platform } from "node:os";
+import { randomUUID } from "node:crypto";
+
+import { detectRuntimeCapabilities } from "./capabilities";
+import type { MachineHeartbeat } from "./protocol";
+
+const CONNECTOR_VERSION = "0.1.0-experimental";
+
+function defaultMachineIdPath() {
+  return join(homedir(), ".nolo", "machine-id");
+}
+
+export function resolveMachineId(path = defaultMachineIdPath()) {
+  try {
+    if (existsSync(path)) {
+      const existing = readFileSync(path, "utf8").trim();
+      if (existing) return existing;
+    }
+    const next = `machine-${randomUUID()}`;
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${next}\n`, "utf8");
+    return next;
+  } catch {
+    return `machine-${hostname().toLowerCase()}`;
+  }
+}
+
+export function detectMachineInfo(overrides?: {
+  machineId?: string;
+  name?: string;
+  capabilities?: string[];
+  probeLaunchable?: boolean;
+}): MachineHeartbeat {
+  return {
+    machineId: overrides?.machineId ?? resolveMachineId(),
+    name: overrides?.name ?? hostname(),
+    platform: platform(),
+    arch: arch(),
+    connectorVersion: CONNECTOR_VERSION,
+    capabilities: overrides?.capabilities ?? detectRuntimeCapabilities({
+      probeLaunchable: overrides?.probeLaunchable,
+    }),
+  };
+}

package/connector-experimental/protocol.ts

@@ -0,0 +1,54 @@
+export type MachineHeartbeatInput = {
+  machineId?: unknown;
+  name?: unknown;
+  platform?: unknown;
+  arch?: unknown;
+  connectorVersion?: unknown;
+  capabilities?: unknown;
+};
+
+export type MachineHeartbeat = {
+  machineId: string;
+  name: string;
+  platform: string;
+  arch: string;
+  connectorVersion?: string;
+  capabilities: string[];
+};
+
+const normalizeRequiredString = (value: unknown, field: string) => {
+  if (typeof value !== "string" || !value.trim()) {
+    throw new Error(`${field} is required`);
+  }
+  return value.trim();
+};
+
+const normalizeOptionalString = (value: unknown) =>
+  typeof value === "string" && value.trim() ? value.trim() : undefined;
+
+export function normalizeCapabilityList(value: unknown): string[] {
+  if (!Array.isArray(value)) return [];
+  const seen = new Set<string>();
+  const result: string[] = [];
+  for (const item of value) {
+    if (typeof item !== "string") continue;
+    const normalized = item.trim();
+    if (!normalized || seen.has(normalized)) continue;
+    seen.add(normalized);
+    result.push(normalized);
+  }
+  return result;
+}
+
+export function normalizeMachineHeartbeat(input: MachineHeartbeatInput): MachineHeartbeat {
+  const heartbeat: MachineHeartbeat = {
+    machineId: normalizeRequiredString(input.machineId, "machineId"),
+    name: normalizeRequiredString(input.name, "name"),
+    platform: normalizeRequiredString(input.platform, "platform"),
+    arch: normalizeRequiredString(input.arch, "arch"),
+    capabilities: normalizeCapabilityList(input.capabilities),
+  };
+  const connectorVersion = normalizeOptionalString(input.connectorVersion);
+  if (connectorVersion) heartbeat.connectorVersion = connectorVersion;
+  return heartbeat;
+}

package/machineCommands.ts

@@ -1,5 +1,5 @@
-import type { MachineHeartbeat } from "connector-experimental/protocol";
-import { detectMachineInfo } from "connector-experimental/machineInfo";
+import type { MachineHeartbeat } from "./connector-experimental/protocol";
+import { detectMachineInfo } from "./connector-experimental/machineInfo";
 import { mkdirSync, openSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
@@ -7,12 +7,12 @@ import { DEFAULT_NOLO_SERVER_URL } from "./defaultServer";
 import {
   type HeartbeatLoopOptions,
   runHeartbeatLoop as defaultRunHeartbeatLoop,
-} from "connector-experimental/heartbeatLoop";
+} from "./connector-experimental/heartbeatLoop";
 import {
   assertMachineRunAllowed,
   buildMachinePermissionPromptBlock,
   resolveMachineRunPermissionPolicy,
-} from "../ai/agent/machineRunPermissions";
+} from "./ai/agent/machineRunPermissions";
 import { resolveConnectorWebSocketTarget } from "./connectorWebSocketTarget";
 
 type EnvLike = Record<string, string | undefined>;
@@ -161,7 +161,7 @@ async function defaultConnectWebSocket(url: string, options: ConnectorWebSocketO
 }
 
 async function defaultExecuteCli(provider: string, prompt: string, options: { model?: string; yolo?: boolean }) {
-  const { executeCli } = await import("ai/agent/cliExecutor");
+  const { executeCli } = await import("./ai/agent/cliExecutor");
   return executeCli(provider as any, prompt, options);
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nolo-cli",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "type": "module",
   "description": "Agent-first terminal workspace for Nolo",
   "bin": {
@@ -16,21 +16,17 @@
     "defaultServer.ts",
     "machineCommands.ts",
     "updateCommands.ts",
-    "client/agentRun.ts",
-    "client/profileConfig.ts",
-    "tui/readlineWorkspace.ts",
-    "tui/session.ts",
-    "README.md"
+    "client/**/*.ts",
+    "tui/**/*.ts",
+    "README.md",
+    "ai/**/*.ts",
+    "connector-experimental/**/*.ts"
   ],
   "publishConfig": {
     "access": "public"
   },
-  "devDependencies": {
-    "bun-types": "latest"
-  },
   "dependencies": {
-    "ai": "workspace:*",
-    "connector-experimental": "workspace:*"
+    "ulid": "^2.3.0"
   },
   "peerDependencies": {
     "typescript": "^5.0.0"