nolo-cli 0.1.32 → 0.1.33

package/client/agentRunTaskRunRecorder.ts

@@ -1,176 +0,0 @@
-import { join } from "node:path";
-
-import type { EnvLike } from "../cliEnvHelpers";
-import type { OutputLike } from "../cliIoTypes";
-import {
-  classifyTaskRunReviewStatus,
-  type TaskRunToolEvidence,
-} from "./agentRunLocalExecution";
-import type { TaskRunPromptContext } from "./taskRunPrompt";
-
-type TaskRunAgentRole = "pm" | "frontend" | "fullstack" | "reviewer" | "codex";
-type TaskRunStatus = "running" | "completed" | "failed";
-
-type TaskRunRecorderOptionShape = {
-  agentName: string;
-  agentKey: string;
-  serverUrl: string;
-  scriptDir: string;
-  env: EnvLike;
-  output: OutputLike;
-  taskRunContext?: TaskRunPromptContext;
-  taskRunRecorder?: unknown;
-};
-
-export type TaskRunRecorderArgs<
-  TOptions extends TaskRunRecorderOptionShape = TaskRunRecorderOptionShape,
-> = {
-  options: TOptions;
-  status: TaskRunStatus;
-  dialogId?: string;
-  resultSummary?: string;
-  errorCode?: string;
-  toolEvidence?: TaskRunToolEvidence;
-};
-
-export type TaskRunRecorder<
-  TOptions extends TaskRunRecorderOptionShape = TaskRunRecorderOptionShape,
-> = (args: TaskRunRecorderArgs<TOptions>) => Promise<void>;
-
-export function inferTaskRunAgentRole(agentRef: string): TaskRunAgentRole {
-  const normalized = agentRef.toLowerCase();
-  if (normalized.includes("project-manager") || normalized.includes("manager")) return "pm";
-  if (normalized.includes("frontend")) return "frontend";
-  if (normalized.includes("fullstack")) return "fullstack";
-  if (normalized.includes("review")) return "reviewer";
-  return "codex";
-}
-
-export async function runTaskRunCli<TOptions extends TaskRunRecorderOptionShape>(args: {
-  options: TOptions;
-  cliArgs: string[];
-}) {
-  const scriptPath = join(args.options.scriptDir, "taskRun.ts");
-  const proc = Bun.spawn({
-    cmd: [process.execPath, scriptPath, ...args.cliArgs],
-    stdout: "pipe",
-    stderr: "pipe",
-    env: {
-      ...process.env,
-      ...args.options.env,
-      BASE_URL: args.options.serverUrl,
-    },
-  });
-  const [stdout, stderr, exitCode] = await Promise.all([
-    new Response(proc.stdout).text(),
-    new Response(proc.stderr).text(),
-    proc.exited,
-  ]);
-  if (exitCode !== 0) {
-    throw new Error((stderr || stdout || `taskRun.ts exited ${exitCode}`).trim());
-  }
-}
-
-export async function defaultTaskRunRecorder<TOptions extends TaskRunRecorderOptionShape>(
-  args: TaskRunRecorderArgs<TOptions>
-) {
-  const context = args.options.taskRunContext;
-  if (!context?.rowDbKey) return;
-  const role = inferTaskRunAgentRole(args.options.agentName || args.options.agentKey);
-  if (role === "reviewer" && args.status !== "running") {
-    await runTaskRunCli({
-      options: args.options,
-      cliArgs: [
-        "request-review",
-        "--row-dbkey",
-        context.rowDbKey,
-        "--base-url",
-        args.options.serverUrl,
-        "--reviewer-agent-key",
-        args.options.agentKey,
-        ...(context.artifactIds?.length ? ["--artifact-ids", context.artifactIds.join(",")] : []),
-        ...(args.dialogId ? ["--dialog-id", args.dialogId] : []),
-      ],
-    });
-  }
-  await runTaskRunCli({
-    options: args.options,
-    cliArgs: [
-      "record-agent-run",
-      "--row-dbkey",
-      context.rowDbKey,
-      "--base-url",
-      args.options.serverUrl,
-      "--agent-key",
-      args.options.agentKey,
-      "--role",
-      role,
-      "--run-status",
-      args.status,
-      ...(context.workItemId ? ["--work-item-id", context.workItemId] : []),
-      ...(args.dialogId ? ["--dialog-id", args.dialogId] : []),
-      ...(args.resultSummary ? ["--result-summary", args.resultSummary.slice(0, 240)] : []),
-      ...(args.errorCode ? ["--error-code", args.errorCode] : []),
-      ...(args.toolEvidence?.toolsUsed?.length
-        ? ["--tools-used", args.toolEvidence.toolsUsed.join(",")]
-        : []),
-      ...(args.toolEvidence?.summary
-        ? ["--tool-trace-summary", JSON.stringify(args.toolEvidence.summary)]
-        : []),
-    ],
-  });
-  if (context.workItemId && args.dialogId) {
-    await runTaskRunCli({
-      options: args.options,
-      cliArgs: [
-        "update-work-item",
-        "--row-dbkey",
-        context.rowDbKey,
-        "--base-url",
-        args.options.serverUrl,
-        "--id",
-        context.workItemId,
-        "--dialog-ids",
-        args.dialogId,
-      ],
-    });
-  }
-  if (role === "reviewer" && args.status !== "running") {
-    const reviewStatus =
-      args.status === "failed" ? "blocked" : classifyTaskRunReviewStatus(args.resultSummary);
-    if (reviewStatus) {
-      await runTaskRunCli({
-        options: args.options,
-        cliArgs: [
-          "review-result",
-          "--row-dbkey",
-          context.rowDbKey,
-          "--base-url",
-          args.options.serverUrl,
-          "--review-status",
-          reviewStatus,
-          "--reviewer-agent-key",
-          args.options.agentKey,
-          ...(context.artifactIds?.length ? ["--artifact-ids", context.artifactIds.join(",")] : []),
-          ...(args.dialogId ? ["--dialog-id", args.dialogId] : []),
-        ],
-      });
-    }
-  }
-}
-
-export async function recordTaskRunOutcome<TOptions extends TaskRunRecorderOptionShape>(
-  args: TaskRunRecorderArgs<TOptions>
-) {
-  if (!args.options.taskRunContext?.rowDbKey) return;
-  try {
-    const recorder =
-      (args.options.taskRunRecorder as TaskRunRecorder<TOptions> | undefined) ??
-      ((nextArgs: TaskRunRecorderArgs<TOptions>) => defaultTaskRunRecorder(nextArgs));
-    await recorder(args);
-  } catch (error) {
-    args.options.output.write(
-      `[nolo] task-run writeback failed: ${error instanceof Error ? error.message : String(error)}\n`
-    );
-  }
-}

package/connector-experimental/daemonLauncher.ts

@@ -1,223 +0,0 @@
-import { spawn } from "node:child_process";
-import { existsSync, mkdirSync, openSync, readFileSync, realpathSync } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, isAbsolute, join, relative, resolve } from "node:path";
-
-export type ConnectorDaemonEnv = Record<string, string | undefined>;
-
-export type ConnectorDaemonOutput = {
-  write(chunk: string): void;
-};
-
-type PackageJson = {
-  name?: string;
-  workspaces?: string[] | { packages?: string[] };
-};
-
-const CONNECTOR_RUNTIME_WORKSPACE_PACKAGES = new Set([
-  "connector-experimental",
-  "ai",
-]);
-
-function readJsonFile<T>(path: string): T | null {
-  try {
-    return JSON.parse(readFileSync(path, "utf8")) as T;
-  } catch {
-    return null;
-  }
-}
-
-function getWorkspacePatterns(packageJson: PackageJson) {
-  if (Array.isArray(packageJson.workspaces)) return packageJson.workspaces;
-  return packageJson.workspaces?.packages ?? [];
-}
-
-function normalizePath(path: string) {
-  const resolved = resolve(path);
-  return process.platform === "win32" ? resolved.toLowerCase() : resolved;
-}
-
-function isInsideOrSame(path: string, parent: string) {
-  const relativePath = relative(parent, path);
-  return relativePath === "" || (!relativePath.startsWith("..") && !isAbsolute(relativePath));
-}
-
-function findWorkspaceRoot(startPath: string) {
-  let current = resolve(startPath);
-  while (true) {
-    const packageJsonPath = join(current, "package.json");
-    if (existsSync(packageJsonPath)) {
-      const packageJson = readJsonFile<PackageJson>(packageJsonPath);
-      if (packageJson && getWorkspacePatterns(packageJson).length > 0) {
-        return current;
-      }
-    }
-    const parent = dirname(current);
-    if (parent === current) return null;
-    current = parent;
-  }
-}
-
-export function validateConnectorWorkspaceLinks(cwd: string) {
-  const repoRoot = findWorkspaceRoot(cwd);
-  if (!repoRoot) return [];
-
-  const rootPackageJson = readJsonFile<PackageJson>(join(repoRoot, "package.json"));
-  if (!rootPackageJson) return [];
-
-  const normalizedRepoRoot = normalizePath(realpathSync(repoRoot));
-  const errors: string[] = [];
-
-  for (const pattern of getWorkspacePatterns(rootPackageJson)) {
-    if (!pattern.endsWith("/*")) continue;
-    const workspaceParent = join(repoRoot, pattern.slice(0, -2));
-    if (!existsSync(workspaceParent)) continue;
-
-    for (const entry of Array.from(new Bun.Glob("*/package.json").scanSync({ cwd: workspaceParent }))) {
-      const packageDir = join(workspaceParent, dirname(entry));
-      const packageJson = readJsonFile<PackageJson>(join(workspaceParent, entry));
-      if (!packageJson?.name || !CONNECTOR_RUNTIME_WORKSPACE_PACKAGES.has(packageJson.name)) {
-        continue;
-      }
-
-      const linkPath = join(repoRoot, "node_modules", ...packageJson.name.split("/"));
-      if (!existsSync(linkPath)) {
-        errors.push(`${linkPath} is missing. Run bun install in ${repoRoot}.`);
-        continue;
-      }
-
-      const actualPath = normalizePath(realpathSync(linkPath));
-      const expectedPath = normalizePath(realpathSync(packageDir));
-      if (!isInsideOrSame(actualPath, normalizedRepoRoot)) {
-        errors.push(
-          `${linkPath} points outside this checkout: ${actualPath}. Run bun install in ${repoRoot}.`,
-        );
-        continue;
-      }
-      if (actualPath !== expectedPath) {
-        errors.push(
-          `${linkPath} points at ${actualPath}, expected ${expectedPath}. Run bun install in ${repoRoot}.`,
-        );
-      }
-    }
-  }
-
-  return errors;
-}
-
-export async function checkConnectorWorkspaceLinks(
-  cwd: string,
-  output: ConnectorDaemonOutput,
-  validateWorkspaceLinks: (cwd: string) => string[] | Promise<string[]>,
-) {
-  const errors = await validateWorkspaceLinks(cwd);
-  if (errors.length === 0) return true;
-  output.write(
-    [
-      "[nolo] Connector workspace package links are unsafe.",
-      "The connector would import workspace packages from a different checkout, so machine capabilities and runtime behavior may be stale.",
-      ...errors,
-      "",
-    ].join("\n"),
-  );
-  return false;
-}
-
-export function resolveDaemonLogPath(env: ConnectorDaemonEnv) {
-  return env.NOLO_CONNECT_LOG || join(homedir(), ".nolo", "logs", "connector.log");
-}
-
-export function buildConnectorDaemonEnv(env: ConnectorDaemonEnv, cwd: string) {
-  return {
-    ...env,
-    NOLO_CONNECTOR_WORKDIR: env.NOLO_CONNECTOR_WORKDIR?.trim() || cwd,
-    NOLO_AGENT_WORKDIR: env.NOLO_AGENT_WORKDIR?.trim() || cwd,
-    NOLO_LOCAL_WORKTREE: env.NOLO_LOCAL_WORKTREE?.trim() || cwd,
-  };
-}
-
-function firstNonEmptyValue(...values: Array<string | undefined>) {
-  for (const value of values) {
-    if (typeof value === "string" && value.trim()) return value.trim();
-  }
-  return "";
-}
-
-export function buildDaemonCommand(
-  cliEntrypointPath: string | undefined,
-  env: ConnectorDaemonEnv,
-  fallbackEntrypointPath = import.meta.path,
-) {
-  const command = [process.execPath, cliEntrypointPath || fallbackEntrypointPath, "connect", "--ws"];
-  const serverUrl = firstNonEmptyValue(env.NOLO_SERVER, env.NOLO_SERVER_URL, env.BASE_URL);
-  const authToken = firstNonEmptyValue(
-    env.NOLO_MACHINE_API_KEY,
-    env.AUTH_TOKEN,
-    env.AUTH,
-    env.BENCHMARK_AUTH_TOKEN,
-  );
-  if (serverUrl) {
-    command.push("--server-url", serverUrl);
-  }
-  if (authToken) {
-    command.push("--api-key", authToken);
-  }
-  return command;
-}
-
-export function defaultSpawnDaemon(args: {
-  cmd: string[];
-  cwd: string;
-  env: ConnectorDaemonEnv;
-  logPath: string;
-}) {
-  mkdirSync(dirname(args.logPath), { recursive: true });
-  const out = openSync(args.logPath, "a");
-  const env = Object.fromEntries(
-    Object.entries(args.env).filter((entry): entry is [string, string] => typeof entry[1] === "string")
-  );
-  const proc = spawn(args.cmd[0], args.cmd.slice(1), {
-    cwd: args.cwd,
-    env,
-    detached: true,
-    stdio: ["ignore", out, out],
-  });
-  proc.unref();
-  return { pid: proc.pid };
-}
-
-export type ConnectorDaemonDeps = {
-  env?: ConnectorDaemonEnv;
-  output?: ConnectorDaemonOutput;
-  cliEntrypointPath?: string;
-  cwd?: string;
-  fallbackEntrypointPath?: string;
-  validateWorkspaceLinks?: (cwd: string) => string[] | Promise<string[]>;
-  spawnDaemon?: (args: {
-    cmd: string[];
-    cwd: string;
-    env: ConnectorDaemonEnv;
-    logPath: string;
-  }) => { pid?: number };
-};
-
-export async function runConnectorDaemon(deps: ConnectorDaemonDeps = {}) {
-  const env = deps.env ?? process.env;
-  const output = deps.output ?? process.stdout;
-  const cwd = deps.cwd ?? process.cwd();
-  const validateWorkspaceLinks = deps.validateWorkspaceLinks ?? validateConnectorWorkspaceLinks;
-
-  if (!(await checkConnectorWorkspaceLinks(cwd, output, validateWorkspaceLinks))) {
-    return 1;
-  }
-
-  const logPath = resolveDaemonLogPath(env);
-  const result = (deps.spawnDaemon ?? defaultSpawnDaemon)({
-    cmd: buildDaemonCommand(deps.cliEntrypointPath, env, deps.fallbackEntrypointPath),
-    cwd,
-    env: buildConnectorDaemonEnv(env, cwd),
-    logPath,
-  });
-  output.write(`Connector daemon started${result.pid ? ` pid=${result.pid}` : ""}. Log: ${logPath}\n`);
-  return 0;
-}

package/create/space/spaceKeys.ts

@@ -1,65 +0,0 @@
-const SEPARATOR = "-";
-const SPACE_PREFIX = "space";
-const SPACE_PREFIX_WITH_SEPARATOR = `${SPACE_PREFIX}${SEPARATOR}`;
-
-export const normalizeSpaceId = (spaceId: string) => {
-  if (!spaceId) return spaceId;
-  return spaceId.startsWith(SPACE_PREFIX_WITH_SEPARATOR)
-    ? spaceId.slice(SPACE_PREFIX_WITH_SEPARATOR.length)
-    : spaceId;
-};
-
-export const createSpaceKey = {
-  // 空间基础信息的key
-  space: (spaceId: string) => {
-    return [SPACE_PREFIX, normalizeSpaceId(spaceId)].join(SEPARATOR);
-  },
-
-  // 空间成员的key
-  member: (userId: string, spaceId: string) => {
-    return [SPACE_PREFIX, "member", userId, normalizeSpaceId(spaceId)].join(
-      SEPARATOR
-    );
-  },
-
-  // 查询用户所在的所有空间的范围
-  memberRange: (userId: string) => {
-    return {
-      start: [SPACE_PREFIX, "member", userId, ""].join(SEPARATOR),
-      end: [SPACE_PREFIX, "member", userId, "\uffff"].join(SEPARATOR),
-    };
-  },
-
-  /**
-   * 预留：未来若出现“按用户、按空间、且必须跨设备同步”的空间级偏好，
-   * 统一使用这个 key family。当前产品主链不要依赖它。
-   */
-  setting: (userId: string, spaceId: string) => {
-    return [SPACE_PREFIX, "setting", userId, normalizeSpaceId(spaceId)].join(
-      SEPARATOR
-    );
-  },
-
-  /**
-   * 预留：未来如确实需要批量读取空间级远端偏好，再使用这个范围。
-   */
-  settingRange: (userId: string) => {
-    return {
-      start: [SPACE_PREFIX, "setting", userId, ""].join(SEPARATOR),
-      end: [SPACE_PREFIX, "setting", userId, "\uffff"].join(SEPARATOR),
-    };
-  },
-
-  // 从成员key中提取空间key
-  spaceFromMember: (memberKey: string) => {
-    const parts = memberKey.split(SEPARATOR);
-    const spaceId = parts[parts.length - 1];
-    return [SPACE_PREFIX, spaceId].join(SEPARATOR);
-  },
-
-  // 从成员key中提取空间ID
-  spaceIdFromMember: (memberKey: string) => {
-    const parts = memberKey.split(SEPARATOR);
-    return parts[parts.length - 1];
-  },
-};

package/create/types.ts

@@ -1,21 +0,0 @@
-// create/types.ts
-export enum DataType {
-  AGENT = "agent",
-  CYBOT = "cybot",
-  DOC = "page",
-  DIALOG = "dialog",
-  NOTIFICATION = "notification",
-  MSG = "msg",
-  TOKEN = "token",
-  SPACE = "space",
-  TRANSACTION = "transaction",
-  SETTING = "setting",
-  TASK = "task",
-
-  TABLE = "table",
-  TABLE_ROW = "table_row",
-  FILE = "file",
-  IMAGE = "image",
-  APP = "app",
-  EMAIL = "email",
-}

package/customCodingAgentFlow.ts

@@ -1,208 +0,0 @@
-export type CodingAgentServerEntry = {
-  baseUrl: string;
-  userId: string;
-  authToken: string;
-};
-
-export type CodingAgentWriteResult = {
-  privateKey: string;
-  contentKey: string;
-};
-
-export type CodingAgentVerifyResult = {
-  dialogId: string;
-  content: string;
-};
-
-export type CodingAgentFlowDeps = {
-  ensureAccess: (args: {
-    baseUrl: string;
-    seed: string;
-    username: string;
-    locale: string;
-  }) => Promise<{ userId: string; authToken: string }>;
-  ensureAccessOnBases: (args: {
-    baseUrl: string;
-    seed: string;
-    username: string;
-    locale: string;
-  }) => Promise<CodingAgentServerEntry[]>;
-  upsertAgentRecordOnBases: (args: {
-    serverEntries: CodingAgentServerEntry[];
-    agentRecord: Record<string, any>;
-  }) => Promise<CodingAgentWriteResult[]>;
-  attachAgentToSpace: (args: {
-    baseUrl: string;
-    userId: string;
-    authToken: string;
-    spaceId: string;
-    contentKey: string;
-    title: string;
-  }) => Promise<void>;
-  verifyAgentResponse: (args: {
-    baseUrl: string;
-    authToken: string;
-    agentKey: string;
-    prompt: string;
-    expected: string;
-    maxRounds: number;
-  }) => Promise<CodingAgentVerifyResult>;
-  resolveTargetSpaceId: (spaceId?: string) => string | undefined;
-  now?: () => number;
-};
-
-export type CreateCodingAgentFromRecordOptions = {
-  baseUrl: string;
-  spaceId?: string;
-  localCoreBaseUrl?: string;
-  seed?: string;
-  username?: string;
-  locale?: string;
-  agentId: string;
-  skipVerify?: boolean;
-  verifyPrompt?: string;
-  expectedResponse?: string;
-  verifyRounds?: number;
-  syncAllBases?: boolean;
-  buildRecord: (args: {
-    userId: string;
-    now: number;
-    agentId: string;
-  }) => Record<string, any>;
-};
-
-export function normalizeCodingAgentBaseUrl(baseUrl: string): string {
-  return baseUrl.replace(/\/+$/, "");
-}
-
-export function splitCodingAgentServerEntries(
-  serverEntries: CodingAgentServerEntry[],
-  attachBaseUrl: string
-) {
-  const normalizedAttachBaseUrl = normalizeCodingAgentBaseUrl(attachBaseUrl);
-  const runtimeEntries = serverEntries.map((entry) => ({
-    ...entry,
-    baseUrl: normalizeCodingAgentBaseUrl(entry.baseUrl),
-  }));
-  const attachEntries = runtimeEntries.filter(
-    (entry) => entry.baseUrl === normalizedAttachBaseUrl
-  );
-
-  return {
-    runtimeEntries,
-    attachEntries,
-    needsAttachLogin: attachEntries.length === 0,
-  };
-}
-
-export async function createCodingAgentFromRecord(
-  options: CreateCodingAgentFromRecordOptions,
-  deps: CodingAgentFlowDeps
-) {
-  const {
-    baseUrl,
-    spaceId,
-    localCoreBaseUrl,
-    seed = process.env.AGENT_SEED ?? "nolo-platform-demo-account-v1",
-    username = process.env.AGENT_USER ?? "platform-demo",
-    locale = process.env.AGENT_LOCALE ?? "zh-CN",
-    agentId,
-    skipVerify = false,
-    verifyPrompt = "只回复 OK",
-    expectedResponse = "OK",
-    verifyRounds = 2,
-    syncAllBases = true,
-    buildRecord,
-  } = options;
-
-  const attachSpaceId = deps.resolveTargetSpaceId(spaceId);
-  const attachBaseUrl = normalizeCodingAgentBaseUrl(localCoreBaseUrl ?? baseUrl);
-  const serverEntries = syncAllBases
-    ? await deps.ensureAccessOnBases({
-        baseUrl,
-        seed,
-        username,
-        locale,
-      })
-    : [
-        {
-          baseUrl,
-          ...(await deps.ensureAccess({
-            baseUrl,
-            seed,
-            username,
-            locale,
-          })),
-        },
-      ];
-  const entryPlan = splitCodingAgentServerEntries(serverEntries, attachBaseUrl);
-  const attachEntries = entryPlan.needsAttachLogin
-    ? [
-        {
-          baseUrl: attachBaseUrl,
-          ...(await deps.ensureAccess({
-            baseUrl: attachBaseUrl,
-            seed,
-            username,
-            locale,
-          })),
-        },
-      ]
-    : entryPlan.attachEntries;
-  const allEntries = [
-    ...entryPlan.runtimeEntries,
-    ...attachEntries.filter(
-      (attachEntry) =>
-        !entryPlan.runtimeEntries.some((runtimeEntry) => runtimeEntry.baseUrl === attachEntry.baseUrl)
-    ),
-  ];
-  const primaryEntry = allEntries[0];
-  const { userId, authToken } = primaryEntry;
-  const now = deps.now?.() ?? Date.now();
-  const agentRecord = buildRecord({
-    userId,
-    now,
-    agentId,
-  });
-
-  const [{ privateKey, contentKey }] = await deps.upsertAgentRecordOnBases({
-    serverEntries: allEntries,
-    agentRecord,
-  });
-  if (attachSpaceId) {
-    for (const entry of attachEntries) {
-      await deps.attachAgentToSpace({
-        baseUrl: entry.baseUrl,
-        userId,
-        authToken: entry.authToken,
-        spaceId: attachSpaceId,
-        contentKey,
-        title: agentRecord.name ?? agentId,
-      });
-    }
-  }
-
-  const verify = skipVerify
-    ? { dialogId: "", content: "SKIPPED" }
-    : await deps.verifyAgentResponse({
-        baseUrl: primaryEntry.baseUrl,
-        authToken,
-        agentKey: privateKey,
-        prompt: verifyPrompt,
-        expected: expectedResponse,
-        maxRounds: verifyRounds,
-      });
-
-  return {
-    userId,
-    authToken,
-    agentId,
-    privateKey,
-    agentUrl: `${primaryEntry.baseUrl}/${privateKey}`,
-    spaceId: attachSpaceId,
-    verify,
-    replicatedBases: allEntries.map((entry) => entry.baseUrl),
-    verifiedBase: primaryEntry.baseUrl,
-    agentRecord,
-  };
-}