cueloop 0.1.0-alpha.9 → 0.1.0-alpha.91

package/src/dev-command.ts

@@ -0,0 +1,112 @@
+/**
+ * `cueloop dev`: open the TUI against an isolated dev home seeded once with a
+ * plan and a diff under this repo's project plus a standalone reply thread, so
+ * the Projects and Threads sidebar and the thread view are populated without a
+ * live agent. It never touches the real ~/.cueloop home.
+ */
+
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { DaemonClient } from "@cueloop/daemon/client";
+import { resolveWorkspace } from "@cueloop/daemon/thread-review";
+
+/** Bump whenever the seed content below changes, so a long-lived dev home refreshes instead of keeping
+ *  stale threads (an old seed's diff had no files, which showed as "No changes"). */
+const SEED_VERSION = 2;
+const SEED_TITLES = new Set([
+  "Read the repository",
+  "Review the accent change",
+  "A standalone thought",
+]);
+
+const SEED_PLAN = `# Read the repository
+
+A seeded plan so \`cueloop dev\` always has a thread to open.
+
+## Steps
+- open the thread view
+- move the cursor into the agent's text
+- type to leave a comment
+`;
+
+const SEED_REPLY = `A standalone thought, not tied to any repository.
+
+It lands under Threads in the sidebar rather than a project.
+`;
+
+const SEED_DIFF_PATH = "packages/client/src/theme.ts";
+const SEED_DIFF_OLD = '  accent: "#f5a3a3",\n';
+const SEED_DIFF_NEW = '  accent: "#cba6f7",\n';
+const SEED_DIFF = `diff --git a/${SEED_DIFF_PATH} b/${SEED_DIFF_PATH}
+--- a/${SEED_DIFF_PATH}
++++ b/${SEED_DIFF_PATH}
+@@ -1 +1 @@
+-${SEED_DIFF_OLD.trimEnd()}
++${SEED_DIFF_NEW.trimEnd()}
+`;
+
+async function seedDevSessions(client: DaemonClient): Promise<void> {
+  // the current repo carries a root commit, so its threads gather under a project
+  const project = await resolveWorkspace(process.cwd());
+  // a non-repo directory has no root commit, so its thread stays standalone
+  const standalone = await resolveWorkspace(tmpdir());
+
+  await client.sessionCreate(project, {
+    type: "plan",
+    content: SEED_PLAN,
+    meta: { title: "Read the repository" },
+  });
+  await client.sessionCreate(project, {
+    type: "diff",
+    content: SEED_DIFF,
+    meta: { title: "Review the accent change" },
+    files: [
+      {
+        path: SEED_DIFF_PATH,
+        oldContents: SEED_DIFF_OLD,
+        newContents: SEED_DIFF_NEW,
+        status: "modified",
+      },
+    ],
+  });
+  await client.sessionCreate(standalone, {
+    type: "reply",
+    content: SEED_REPLY,
+    meta: { title: "A standalone thought" },
+  });
+}
+
+/** Seed the dev home, refreshing the seed threads when SEED_VERSION moved on so a stale home never
+ *  keeps an old seed (which is why an aged home showed "No changes" - its diff thread had no files). */
+async function refreshDevSeed(client: DaemonClient, home: string): Promise<void> {
+  const versionFile = join(home, ".seed-version");
+  const stored = existsSync(versionFile) ? Number(readFileSync(versionFile, "utf8").trim()) : 0;
+  const existing = await client.sessionList();
+  if (existing.length > 0 && stored === SEED_VERSION) return;
+
+  await Promise.all(
+    existing
+      .filter((thread) => SEED_TITLES.has(thread.artifact.meta.title ?? ""))
+      .map((thread) => client.sessionDelete(thread.id)),
+  );
+  await seedDevSessions(client);
+  mkdirSync(dirname(versionFile), { recursive: true });
+  writeFileSync(versionFile, String(SEED_VERSION));
+}
+
+/** `cueloop dev`: seed an isolated dev home (refreshing a stale seed), then open the TUI on it. */
+export async function devCommand(): Promise<number> {
+  const home = (process.env.CUELOOP_HOME ??= join(homedir(), ".cueloop-dev"));
+
+  const client = await DaemonClient.connect({ autostart: true });
+  try {
+    await refreshDevSeed(client, home);
+  } finally {
+    client.close();
+  }
+
+  const { runClient } = await import("@cueloop/client");
+
+  return runClient({});
+}

package/src/harness-command.ts

@@ -0,0 +1,16 @@
+import { runHarnessBridge } from "@cueloop/adapters/harness-bridge";
+
+export async function harnessCommand(): Promise<number> {
+  try {
+    const request = JSON.parse(await new Response(Bun.stdin.stream()).text());
+    const response = await runHarnessBridge(request);
+
+    console.log(JSON.stringify(response));
+
+    return 0;
+  } catch (error) {
+    console.error(`cueloop harness bridge failed: ${String(error)}`);
+
+    return 1;
+  }
+}

package/src/install-command.test.ts

@@ -0,0 +1,142 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { installExtensionCommand } from "./install-command";
+
+const roots: string[] = [];
+
+afterEach(() => {
+  for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true });
+});
+
+function testRoot(): string {
+  const root = mkdtempSync(join(tmpdir(), "cueloop-install-test-"));
+
+  roots.push(root);
+
+  return root;
+}
+
+describe("cueloop install", () => {
+  test("rejects sources outside npm without running a package command", async () => {
+    const root = testRoot();
+    let called = false;
+
+    expect(
+      await installExtensionCommand(["file:./extension"], {
+        installRoot: root,
+        runPackageCommand: async () => {
+          called = true;
+
+          return { exitCode: 0, stderr: "" };
+        },
+      }),
+    ).toBe(2);
+    expect(called).toBe(false);
+  });
+
+  test("installs a package whose manifest declares a client entry", async () => {
+    const root = testRoot();
+    const commands: string[][] = [];
+    const result = await installExtensionCommand(["npm:@example/tools@1.0.0"], {
+      installRoot: root,
+      runPackageCommand: async (args) => {
+        commands.push(args);
+        const packageRoot = join(root, "node_modules", "@example/tools");
+
+        mkdirSync(packageRoot, { recursive: true });
+        writeFileSync(
+          join(root, "package.json"),
+          JSON.stringify({ dependencies: { "@example/tools": "1.0.0" } }),
+        );
+        writeFileSync(
+          join(packageRoot, "package.json"),
+          JSON.stringify({ cueloop: { client: "./client.js" } }),
+        );
+        writeFileSync(join(packageRoot, "client.js"), "export default () => {};");
+
+        return { exitCode: 0, stderr: "" };
+      },
+    });
+
+    expect(result).toBe(0);
+    expect(commands).toEqual([["add", "--ignore-scripts", "--cwd", root, "@example/tools@1.0.0"]]);
+    expect(JSON.parse(readFileSync(join(root, "package.json"), "utf8")).dependencies).toEqual({
+      "@example/tools": "1.0.0",
+    });
+  });
+
+  test("removes a package without a cueloop manifest", async () => {
+    const root = testRoot();
+    const commands: string[][] = [];
+    const result = await installExtensionCommand(["npm:example"], {
+      installRoot: root,
+      runPackageCommand: async (args) => {
+        commands.push(args);
+        if (args[0] === "add") {
+          const packageRoot = join(root, "node_modules", "example");
+
+          mkdirSync(packageRoot, { recursive: true });
+          writeFileSync(
+            join(root, "package.json"),
+            JSON.stringify({ dependencies: { example: "1.0.0" } }),
+          );
+          writeFileSync(join(packageRoot, "package.json"), "{}");
+        }
+
+        return { exitCode: 0, stderr: "" };
+      },
+    });
+
+    expect(result).toBe(1);
+    expect(commands[1]).toEqual(["remove", "--ignore-scripts", "--cwd", root, "example"]);
+  });
+
+  test("restores the prior version after an invalid upgrade", async () => {
+    const root = testRoot();
+    const packageRoot = join(root, "node_modules", "example");
+    const commands: string[][] = [];
+
+    mkdirSync(packageRoot, { recursive: true });
+    writeFileSync(
+      join(root, "package.json"),
+      JSON.stringify({ dependencies: { example: "1.0.0" } }),
+    );
+    writeFileSync(
+      join(packageRoot, "package.json"),
+      JSON.stringify({ version: "1.0.0", cueloop: { client: "./client.js" } }),
+    );
+    writeFileSync(join(packageRoot, "client.js"), "export default () => {};");
+    const result = await installExtensionCommand(["npm:example@2.0.0"], {
+      installRoot: root,
+      runPackageCommand: async (args) => {
+        commands.push(args);
+        if (args.at(-1) === "example@2.0.0") {
+          writeFileSync(
+            join(root, "package.json"),
+            JSON.stringify({ dependencies: { example: "2.0.0" } }),
+          );
+          writeFileSync(join(packageRoot, "package.json"), JSON.stringify({ version: "2.0.0" }));
+        } else {
+          writeFileSync(
+            join(root, "package.json"),
+            JSON.stringify({ dependencies: { example: "1.0.0" } }),
+          );
+          writeFileSync(
+            join(packageRoot, "package.json"),
+            JSON.stringify({ version: "1.0.0", cueloop: { client: "./client.js" } }),
+          );
+        }
+
+        return { exitCode: 0, stderr: "" };
+      },
+    });
+
+    expect(result).toBe(1);
+    expect(commands[1]).toEqual(["add", "--ignore-scripts", "--cwd", root, "example@1.0.0"]);
+    expect(JSON.parse(readFileSync(join(root, "package.json"), "utf8")).dependencies.example).toBe(
+      "1.0.0",
+    );
+  });
+});

package/src/install-command.ts

@@ -0,0 +1,114 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import * as v from "valibot";
+import {
+  discoverInstalledExtensionPackages,
+  extensionInstallRoot,
+} from "@cueloop/extension-api/installed-packages";
+
+const NPM_PACKAGE_SOURCE = /^npm:((?:@[a-z0-9_.-]+\/)?[a-z0-9_.-]+)(?:@([^\s/]+))?$/i;
+
+interface PackageCommandResult {
+  exitCode: number;
+  stderr: string;
+}
+
+interface InstallOptions {
+  installRoot?: string;
+  runPackageCommand?: (args: string[]) => Promise<PackageCommandResult>;
+}
+
+async function runPackageCommand(args: string[]): Promise<PackageCommandResult> {
+  // A compiled executable can invoke its bundled Bun CLI without `bun` on PATH.
+  const child = Bun.spawn([process.execPath, ...args], {
+    env: { ...process.env, BUN_BE_BUN: "1" },
+    stdout: "ignore",
+    stderr: "pipe",
+  });
+  const [exitCode, stderr] = await Promise.all([child.exited, new Response(child.stderr).text()]);
+
+  return { exitCode, stderr };
+}
+
+function previousPackageSpec(installRoot: string, name: string): string | null {
+  const path = join(installRoot, "node_modules", name, "package.json");
+
+  if (!existsSync(path)) return null;
+  try {
+    const parsed = v.safeParse(
+      v.object({ version: v.pipe(v.string(), v.minLength(1)) }),
+      JSON.parse(readFileSync(path, "utf8")),
+    );
+
+    return parsed.success ? `${name}@${parsed.output.version}` : null;
+  } catch {
+    return null;
+  }
+}
+
+/** Install a user-level npm extension after checking its declared entry points. */
+export async function installExtensionCommand(
+  argv: string[],
+  options: InstallOptions = {},
+): Promise<number> {
+  const source = argv[0];
+  const match = source?.match(NPM_PACKAGE_SOURCE);
+
+  if (argv.length !== 1 || !match) {
+    console.error("cueloop install: expected npm:<package>[@version]");
+
+    return 2;
+  }
+  const name = match[1]!;
+  const spec = source!.slice("npm:".length);
+  const installRoot = options.installRoot ?? extensionInstallRoot();
+  const runCommand = options.runPackageCommand ?? runPackageCommand;
+  const previousSpec = previousPackageSpec(installRoot, name);
+
+  mkdirSync(installRoot, { recursive: true });
+  const rootManifest = join(installRoot, "package.json");
+
+  if (!existsSync(rootManifest)) {
+    writeFileSync(
+      rootManifest,
+      JSON.stringify({ name: "cueloop-extensions", private: true }, null, 2),
+    );
+  }
+  const { exitCode, stderr } = await runCommand([
+    "add",
+    "--ignore-scripts",
+    "--cwd",
+    installRoot,
+    spec,
+  ]);
+
+  if (exitCode !== 0) {
+    console.error(`cueloop install: ${stderr.trim() || "bun add failed"}`);
+
+    return 1;
+  }
+  const discovered = discoverInstalledExtensionPackages(installRoot);
+  const installed = discovered.packages.find((entry) => entry.name === name);
+
+  if (!installed) {
+    const error = discovered.errors.find((message) => message.includes(` ${name}:`));
+    console.error(`cueloop install: ${error ?? `extension ${name} has no valid cueloop manifest`}`);
+    const restored = await runCommand(
+      previousSpec
+        ? ["add", "--ignore-scripts", "--cwd", installRoot, previousSpec]
+        : ["remove", "--ignore-scripts", "--cwd", installRoot, name],
+    );
+
+    if (restored.exitCode !== 0)
+      console.error(
+        `cueloop install: could not restore ${previousSpec ?? name}: ${restored.stderr.trim()}`,
+      );
+
+    return 1;
+  }
+  console.log(
+    `Installed ${name}. Restart cueloop and run 'cueloop restart' to load daemon capabilities.`,
+  );
+
+  return 0;
+}