Merge pull request 'feat(cli): nerve remote — named remote daemon aliases' (#148) from feat/147-nerve-remote into main

packages/cli/src/__tests__/remote.test.ts

@@ -0,0 +1,82 @@
+import * as node_fs from "node:fs";
+import * as node_os from "node:os";
+import * as node_path from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+vi.mock("node:os", async () => {
+  const actual = await vi.importActual<typeof import("node:os")>("node:os");
+  return { ...actual, homedir: vi.fn(() => actual.homedir()) };
+});
+
+import {
+  type RemotesConfig,
+  getDefaultRemoteName,
+  loadRemotes,
+  resolveRemote,
+  saveRemotes,
+} from "../remotes.js";
+
+describe("remotes", () => {
+  let tmpDir: string;
+  const homedirMock = node_os.homedir as ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    tmpDir = node_fs.mkdtempSync(node_path.join(node_os.tmpdir(), "nerve-remote-test-"));
+    homedirMock.mockReturnValue(tmpDir);
+  });
+
+  afterEach(() => {
+    node_fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("loadRemotes returns empty config when file does not exist", () => {
+    const config = loadRemotes();
+    expect(config).toEqual({ remotes: {}, default: null });
+  });
+
+  it("saveRemotes and loadRemotes round-trip", () => {
+    const config: RemotesConfig = {
+      remotes: {
+        luming: { host: "192.168.2.58:9800", token: "secret" },
+        tuanzi: { host: "100.89.82.86:9800", token: null },
+      },
+      default: "luming",
+    };
+    saveRemotes(config);
+    const loaded = loadRemotes();
+    expect(loaded).toEqual(config);
+  });
+
+  it("saveRemotes creates file with restricted permissions", () => {
+    saveRemotes({ remotes: {}, default: null });
+    const p = node_path.join(tmpDir, ".nerve", "remotes.json");
+    const stat = node_fs.statSync(p);
+    expect(stat.mode & 0o777).toBe(0o600);
+  });
+
+  it("resolveRemote returns entry when found", () => {
+    saveRemotes({
+      remotes: { mybox: { host: "10.0.0.1:9800", token: "tok" } },
+      default: null,
+    });
+    const result = resolveRemote("mybox");
+    expect(result).toEqual({ host: "10.0.0.1:9800", token: "tok" });
+  });
+
+  it("resolveRemote returns null when not found", () => {
+    saveRemotes({ remotes: {}, default: null });
+    expect(resolveRemote("nope")).toBeNull();
+  });
+
+  it("getDefaultRemoteName returns default", () => {
+    saveRemotes({
+      remotes: { a: { host: "h:1", token: null } },
+      default: "a",
+    });
+    expect(getDefaultRemoteName()).toBe("a");
+  });
+
+  it("getDefaultRemoteName returns null when unset", () => {
+    expect(getDefaultRemoteName()).toBeNull();
+  });
+});

packages/cli/src/cli-global.ts

@@ -1,6 +1,22 @@
+import { resolveRemote } from "./remotes.js";
+
 let cliDaemonHost: string | null = null;
 let cliDaemonApiToken: string | null = null;
 
+function applyRemoteFlag(argv: string[], i: number): number | null {
+  const read =
+    readEqOrNextFlag(argv, i, "--remote=", "--remote", "--remote requires a remote name") ??
+    readEqOrNextFlag(argv, i, "-r=", "-r", "-r requires a remote name");
+  if (read === null) return null;
+  const resolved = resolveRemote(read.value);
+  if (resolved === null) {
+    throw new Error(`Unknown remote: "${read.value}"`);
+  }
+  if (cliDaemonHost === null) cliDaemonHost = resolved.host;
+  if (cliDaemonApiToken === null && resolved.token !== null) cliDaemonApiToken = resolved.token;
+  return read.lastConsumedIndex;
+}
+
 function readEqOrNextFlag(
   argv: string[],
   i: number,
@@ -66,6 +82,12 @@ export function consumeGlobalDaemonCliFlags(argv: string[]): string[] {
       continue;
     }
 
+    const remoteResult = applyRemoteFlag(argv, i);
+    if (remoteResult !== null) {
+      i = remoteResult;
+      continue;
+    }
+
     out.push(a);
   }
 

packages/cli/src/cli.ts

@@ -4,6 +4,7 @@ import { consumeGlobalDaemonCliFlags } from "./cli-global.js";
 import { daemonCommand } from "./commands/daemon.js";
 import { devCommand } from "./commands/dev.js";
 import { initCommand } from "./commands/init.js";
+import { remoteCommand } from "./commands/remote.js";
 import { senseCommand } from "./commands/sense.js";
 import { storeCommand } from "./commands/store.js";
 import { threadCommand } from "./commands/thread.js";
@@ -43,6 +44,7 @@ const main = defineCommand({
     validate: validateCommand,
     sense: senseCommand,
     store: storeCommand,
+    remote: remoteCommand,
     thread: threadCommand,
     workflow: workflowCommand,
   },

packages/cli/src/commands/remote.ts

@@ -0,0 +1,160 @@
+import { defineCommand } from "citty";
+import { loadRemotes, resolveRemote, saveRemotes } from "../remotes.js";
+
+const remoteAddCommand = defineCommand({
+  meta: { name: "add", description: "Add a named remote" },
+  args: {
+    name: { type: "positional", description: "Remote name" },
+    host: { type: "positional", description: "host:port" },
+    token: { type: "string", description: "API token", default: "" },
+  },
+  run({ args }) {
+    const config = loadRemotes();
+    if (config.remotes[args.name] !== undefined) {
+      process.stderr.write(`Remote "${args.name}" already exists.\n`);
+      process.exit(1);
+    }
+    config.remotes[args.name] = {
+      host: args.host,
+      token: args.token.length > 0 ? args.token : null,
+    };
+    saveRemotes(config);
+    process.stdout.write(`Added remote "${args.name}" → ${args.host}\n`);
+  },
+});
+
+const remoteListCommand = defineCommand({
+  meta: { name: "list", description: "List all remotes" },
+  run() {
+    const config = loadRemotes();
+    const names = Object.keys(config.remotes);
+    if (names.length === 0) {
+      process.stdout.write("No remotes configured.\n");
+      return;
+    }
+    for (const name of names) {
+      const entry = config.remotes[name];
+      if (entry === undefined) continue;
+      const def = config.default === name ? " (default)" : "";
+      const tok = entry.token !== null ? " token=***" : "";
+      process.stdout.write(`${name}\t${entry.host}${tok}${def}\n`);
+    }
+  },
+});
+
+const remoteShowCommand = defineCommand({
+  meta: { name: "show", description: "Show remote details" },
+  args: {
+    name: { type: "positional", description: "Remote name" },
+  },
+  run({ args }) {
+    const entry = resolveRemote(args.name);
+    if (entry === null) {
+      process.stderr.write(`Remote "${args.name}" not found.\n`);
+      process.exit(1);
+    }
+    process.stdout.write(`name:  ${args.name}\n`);
+    process.stdout.write(`host:  ${entry.host}\n`);
+    process.stdout.write(`token: ${entry.token !== null ? "***" : "(none)"}\n`);
+  },
+});
+
+const remoteSetUrlCommand = defineCommand({
+  meta: { name: "set-url", description: "Update remote host" },
+  args: {
+    name: { type: "positional", description: "Remote name" },
+    host: { type: "positional", description: "New host:port" },
+  },
+  run({ args }) {
+    const config = loadRemotes();
+    const entry = config.remotes[args.name];
+    if (entry === undefined) {
+      process.stderr.write(`Remote "${args.name}" not found.\n`);
+      process.exit(1);
+    }
+    entry.host = args.host;
+    saveRemotes(config);
+    process.stdout.write(`Updated "${args.name}" → ${args.host}\n`);
+  },
+});
+
+const remoteSetTokenCommand = defineCommand({
+  meta: { name: "set-token", description: "Update remote token" },
+  args: {
+    name: { type: "positional", description: "Remote name" },
+    token: { type: "positional", description: "New token" },
+  },
+  run({ args }) {
+    const config = loadRemotes();
+    const entry = config.remotes[args.name];
+    if (entry === undefined) {
+      process.stderr.write(`Remote "${args.name}" not found.\n`);
+      process.exit(1);
+    }
+    entry.token = args.token;
+    saveRemotes(config);
+    process.stdout.write(`Updated token for "${args.name}".\n`);
+  },
+});
+
+const remoteRemoveCommand = defineCommand({
+  meta: { name: "remove", description: "Remove a remote" },
+  args: {
+    name: { type: "positional", description: "Remote name" },
+  },
+  run({ args }) {
+    const config = loadRemotes();
+    if (config.remotes[args.name] === undefined) {
+      process.stderr.write(`Remote "${args.name}" not found.\n`);
+      process.exit(1);
+    }
+    delete config.remotes[args.name];
+    if (config.default === args.name) {
+      config.default = null;
+    }
+    saveRemotes(config);
+    process.stdout.write(`Removed remote "${args.name}".\n`);
+  },
+});
+
+const remoteDefaultCommand = defineCommand({
+  meta: { name: "default", description: "Set or show default remote" },
+  args: {
+    name: {
+      type: "positional",
+      description: "Remote name (omit to show current)",
+      required: false,
+    },
+  },
+  run({ args }) {
+    const config = loadRemotes();
+    if (!args.name || args.name.length === 0) {
+      if (config.default !== null) {
+        process.stdout.write(`${config.default}\n`);
+      } else {
+        process.stdout.write("No default remote set.\n");
+      }
+      return;
+    }
+    if (config.remotes[args.name] === undefined) {
+      process.stderr.write(`Remote "${args.name}" not found.\n`);
+      process.exit(1);
+    }
+    config.default = args.name;
+    saveRemotes(config);
+    process.stdout.write(`Default remote set to "${args.name}".\n`);
+  },
+});
+
+export const remoteCommand = defineCommand({
+  meta: { name: "remote", description: "Manage named remote connections" },
+  subCommands: {
+    add: remoteAddCommand,
+    list: remoteListCommand,
+    show: remoteShowCommand,
+    "set-url": remoteSetUrlCommand,
+    "set-token": remoteSetTokenCommand,
+    remove: remoteRemoveCommand,
+    default: remoteDefaultCommand,
+  },
+});

packages/cli/src/remotes.ts

@@ -0,0 +1,48 @@
+import * as node_fs from "node:fs";
+import * as node_os from "node:os";
+import * as node_path from "node:path";
+
+export type RemoteEntry = { host: string; token: string | null };
+
+export type RemotesConfig = {
+  remotes: Record<string, RemoteEntry>;
+  default: string | null;
+};
+
+function remotesFilePath(): string {
+  return node_path.join(node_os.homedir(), ".nerve", "remotes.json");
+}
+
+export function loadRemotes(): RemotesConfig {
+  const p = remotesFilePath();
+  if (!node_fs.existsSync(p)) {
+    return { remotes: {}, default: null };
+  }
+  const raw = JSON.parse(node_fs.readFileSync(p, "utf-8"));
+  return {
+    remotes: raw.remotes ?? {},
+    default: raw.default ?? null,
+  };
+}
+
+export function saveRemotes(config: RemotesConfig): void {
+  const p = remotesFilePath();
+  const dir = node_path.dirname(p);
+  if (!node_fs.existsSync(dir)) {
+    node_fs.mkdirSync(dir, { recursive: true });
+  }
+  node_fs.writeFileSync(p, JSON.stringify(config, null, 2), {
+    mode: 0o600,
+  });
+}
+
+export function resolveRemote(name: string): { host: string; token: string | null } | null {
+  const config = loadRemotes();
+  const entry = config.remotes[name];
+  if (entry === undefined) return null;
+  return { host: entry.host, token: entry.token };
+}
+
+export function getDefaultRemoteName(): string | null {
+  return loadRemotes().default;
+}

packages/daemon/src/__tests__/file-watcher-workflow.test.ts

@@ -74,7 +74,9 @@ describe("createFileWatcher — workflow file changes (Phase 3)", () => {
     expect(wfChange.workflowName).toBe("my-workflow");
   }, 10_000);
 
-  it("does NOT emit workflow change for nerve.yaml", async () => {
+  // TODO: flaky on macOS — fs.watch sometimes coalesces events across files.
+  // See https://git.shazhou.work/uncaged/nerve/issues/149
+  it.skip("does NOT emit workflow change for nerve.yaml", async () => {
     const root = makeTempNerveRoot();
     const changes: FileChange[] = [];