nolo-cli 0.1.22 → 0.1.26

package/client/localRuntimeAdapter.ts

@@ -34,6 +34,7 @@ import {
   type HybridRecordStore,
 } from "./hybridRecordStore";
 import { executeLocalToolWithPolicy } from "./localToolPolicy";
+import { taskRunFunctionSchema } from "../ai/tools/agent/taskRunTool";
 import { prepareTaskWorktree } from "./taskWorktree";
 import {
   activateWorkspaceSession,
@@ -58,6 +59,7 @@ export type CliLocalRuntimeAdapterDeps = {
   createId?: () => string;
   fetchImpl?: typeof fetch;
   cwd?: string;
+  useCwdAsTaskWorkspaceBase?: boolean;
   output?: { write(chunk: string): unknown };
   prepareTaskWorktree?: typeof prepareTaskWorktree;
   localToolExecutors?: Record<string, (call: any) => Promise<{ content: string; metadata?: Record<string, unknown> }>>;
@@ -143,10 +145,13 @@ async function fetchWithTransientRetry(
 
 function buildOpenAiTools(args: { toolNames?: string[]; env: EnvLike }) {
   const toolset = buildLocalWorkspaceToolsetForEnv(args);
-  return buildLocalWorkspaceOpenAiTools({
-    toolNames: toolset.toolNames,
-    exposeShellTools: toolset.exposeShellTools,
-  });
+  return [
+    ...buildLocalWorkspaceOpenAiTools({
+      toolNames: toolset.toolNames,
+      exposeShellTools: toolset.exposeShellTools,
+    }),
+    ...buildServerPlatformOpenAiTools({ toolNames: args.toolNames }),
+  ];
 }
 
 function buildLocalWorkspaceToolsetForEnv(args: { toolNames?: string[]; env: EnvLike }) {
@@ -158,18 +163,86 @@ function buildLocalWorkspaceToolsetForEnv(args: { toolNames?: string[]; env: Env
 }
 
 function buildLocalPolicyToolNames(args: { toolNames?: string[]; env: EnvLike }) {
-  return buildLocalWorkspacePolicyToolNames({
-    declaredToolNames: args.toolNames,
-    exposeShellTools: shellModeEnabled(args.env),
-  });
+  return [
+    ...buildLocalWorkspacePolicyToolNames({
+      declaredToolNames: args.toolNames,
+      exposeShellTools: shellModeEnabled(args.env),
+    }),
+    ...((args.toolNames ?? []).includes("taskRun") ? ["taskRun"] : []),
+  ];
+}
+
+function buildServerPlatformOpenAiTools(args: { toolNames?: string[] }) {
+  const toolNames = new Set(args.toolNames ?? []);
+  return [
+    ...(toolNames.has("taskRun")
+      ? [{
+          type: "function",
+          function: taskRunFunctionSchema,
+        }]
+      : []),
+  ];
+}
+
+function parseToolArguments(raw: string) {
+  try {
+    const parsed = JSON.parse(raw || "{}");
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+function resolveRuntimeServerUrl(env: EnvLike) {
+  return (env.NOLO_SERVER_URL || env.NOLO_SERVER || env.BASE_URL || "").replace(/\/+$/, "");
+}
+
+function resolveRuntimeAuthToken(env: EnvLike) {
+  return env.AUTH_TOKEN || env.AUTH || env.NOLO_MACHINE_API_KEY || "";
+}
+
+function buildServerPlatformToolExecutors(args: {
+  env: EnvLike;
+  fetchImpl: typeof fetch;
+}) {
+  return {
+    taskRun: async (call: any) => {
+      const serverUrl = resolveRuntimeServerUrl(args.env);
+      const authToken = resolveRuntimeAuthToken(args.env);
+      if (!serverUrl) throw new Error("taskRun requires NOLO_SERVER_URL, NOLO_SERVER, or BASE_URL.");
+      if (!authToken) throw new Error("taskRun requires AUTH_TOKEN or NOLO_MACHINE_API_KEY.");
+      const response = await args.fetchImpl(`${serverUrl}/api/task-run`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${authToken}`,
+        },
+        body: JSON.stringify(parseToolArguments(call.arguments)),
+      });
+      const text = await response.text().catch(() => "");
+      if (!response.ok) {
+        throw new Error(`taskRun bridge failed: HTTP ${response.status} ${text.slice(0, 500)}`);
+      }
+      return {
+        content: text,
+        metadata: { serverPlatformTool: true },
+      };
+    },
+  };
 }
 
 function buildLocalToolExecutors(args: {
   workspaceRoot: string;
+  env: EnvLike;
+  fetchImpl: typeof fetch;
   localToolExecutors?: CliLocalRuntimeAdapterDeps["localToolExecutors"];
 }) {
   return {
     ...createLocalWorkspaceToolExecutors({ workspaceRoot: args.workspaceRoot }),
+    ...buildServerPlatformToolExecutors({
+      env: args.env,
+      fetchImpl: args.fetchImpl,
+    }),
     ...(args.localToolExecutors ?? {}),
   };
 }
@@ -254,9 +327,15 @@ export function createCliLocalRuntimeAdapter(
   const localToolBudgets = parseLocalToolBudgets(deps.env);
   const localToolUsage = new Map<string, number>();
   let activeAgentToolNames: string[] = [];
-  let workspaceSession: WorkspaceSession = createWorkspaceSession({ cwd: deps.cwd });
+  let workspaceSession: WorkspaceSession = createWorkspaceSession(
+    deps.useCwdAsTaskWorkspaceBase
+      ? { defaultCwd: deps.cwd }
+      : { cwd: deps.cwd }
+  );
   let localToolExecutors = buildLocalToolExecutors({
     workspaceRoot: workspaceSession.workspaceRoot,
+    env: deps.env,
+    fetchImpl,
     localToolExecutors: deps.localToolExecutors,
   });
 
@@ -274,6 +353,8 @@ export function createCliLocalRuntimeAdapter(
     if (workspaceSession.workspaceRoot === previousWorkspaceRoot) return;
     localToolExecutors = buildLocalToolExecutors({
       workspaceRoot: workspaceSession.workspaceRoot,
+      env: deps.env,
+      fetchImpl,
       localToolExecutors: deps.localToolExecutors,
     });
     deps.output?.write(formatWorkspaceSessionActivation(workspaceSession));
@@ -378,12 +459,20 @@ export function createCliLocalRuntimeAdapter(
         budgets: localToolBudgets,
         usage: localToolUsage,
       });
-      return executeLocalToolWithPolicy({
+      const result = await executeLocalToolWithPolicy({
         env: deps.env,
         agentToolNames: activeAgentToolNames,
         call,
         executors: localToolExecutors,
       });
+      return {
+        ...result,
+        metadata: {
+          ...(result.metadata ?? {}),
+          workspaceRoot: workspaceSession.workspaceRoot,
+          workspaceKind: workspaceSession.kind,
+        },
+      };
     },
   };
 }

package/client/localRuntimeDryRun.test.ts

@@ -4,7 +4,6 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 
 import { runLocalAgentTurn } from "../agent-runtime/localLoop";
-import { buildLocalWorkspaceToolset } from "../agent-runtime/localWorkspaceTools";
 import { createCliLocalRuntimeAdapter } from "./localRuntimeAdapter";
 
 describe("CLI local runtime dry run", () => {
@@ -54,7 +53,11 @@ describe("CLI local runtime dry run", () => {
           completeCount += 1;
           if (completeCount === 1) {
             expect(body.tools.map((tool: any) => tool.function.name)).toEqual([
-              ...buildLocalWorkspaceToolset({}).toolNames,
+              "writeWorkspaceFile",
+              "listFiles",
+              "readFile",
+              "editFile",
+              "searchFiles",
             ]);
             return Response.json({
               model: "qwen-coder",

package/client/taskRunPrompt.ts

@@ -16,6 +16,7 @@ export function prependTaskRunPrompt(message: string, context?: TaskRunPromptCon
     ...(context.taskRunId ? [`- taskRunId: ${context.taskRunId}`] : []),
     ...(context.workItemId ? [`- workItemId: ${context.workItemId}`] : []),
     ...(artifactIds.length ? [`- artifactIds: ${artifactIds.join(",")}`] : []),
+    "- Handoff rule: start from the durable task context, then inspect existing refs such as workItems.dialogIds, workItems.outcome, review.dialogId, activityRefs, agentRuns.dialogId/resultSummary, and artifactRefs. Use dialog read/search for exact evidence.",
     "- When you create, update, hand off, block, or review work, update the task context with `bun run task:run -- ...`.",
     "- If this turn already includes a server TaskRun preflight snapshot, use that snapshot directly for read-only reporting or planning.",
     "- Keep long reasoning and logs in the dialog; record only resumable references in task row meta.",

package/commandRegistry.ts

@@ -1,66 +1,16 @@
-export type CommandEntry = {
-  path: string[];
-  script: string;
-  description: string;
-  fixedArgs?: string[];
-};
+export type { CliPackageInfo, CliRuntimeContext, CommandEntry } from "./cliCommandTypes";
+export {
+  createCliRuntimeContext,
+  looksLikeDaemonShortcut,
+  runResolvedCommand,
+} from "./cliCommandDispatch";
+import type { CommandEntry } from "./cliCommandTypes";
+import { getInternalCommandEntries } from "./internalCommandEntries";
+import { getScriptCommandEntries } from "./scriptCommandEntries";
 
 export const COMMANDS: CommandEntry[] = [
-  { path: ["chat"], script: "", description: "Chat with an agent" },
-
-  { path: ["doc", "create"], script: "createDoc.ts", description: "Create a normal doc" },
-  { path: ["doc", "read"], script: "readDoc.ts", description: "Read a normal doc" },
-  { path: ["doc", "update"], script: "updateDoc.ts", description: "Update a normal doc" },
-  { path: ["doc", "delete"], script: "deleteDoc.ts", description: "Delete a normal doc" },
-
-  { path: ["skill-doc", "create"], script: "createSkillDoc.ts", description: "Create a skill doc" },
-  { path: ["skill-doc", "read"], script: "readSkillDoc.ts", description: "Read a skill doc" },
-  { path: ["skill-doc", "update"], script: "updateSkillDoc.ts", description: "Update a skill doc" },
-  { path: ["skill-doc", "delete"], script: "deleteSkillDoc.ts", description: "Delete a skill doc" },
-  { path: ["skill", "create-doc"], script: "createSkillDoc.ts", description: "Create a skill-backed doc" },
-
-  { path: ["dialog", "read"], script: "readDialog.ts", description: "Read a dialog" },
-  { path: ["dialog", "status"], script: "dialogStatus.ts", description: "Read compact dialog status" },
-  { path: ["space", "list"], script: "listSpaces.ts", description: "List joined spaces" },
-  { path: ["space", "read"], script: "readSpace.ts", description: "Read a space" },
-  { path: ["space", "delete"], script: "deleteSpaces.ts", description: "Delete spaces by safe filters" },
-  { path: ["space", "category"], script: "upsertSpaceCategory.ts", description: "Create or update a space category" },
-  { path: ["space", "content-category"], script: "setSpaceContentCategory.ts", description: "Move content into a space category" },
-
-  { path: ["table", "query"], script: "tableData.ts", fixedArgs: ["--action", "query"], description: "Query table rows" },
-  { path: ["table", "add-column"], script: "tableData.ts", fixedArgs: ["--action", "add-column"], description: "Add one table column" },
-  { path: ["table", "add-row"], script: "tableData.ts", fixedArgs: ["--action", "add-row"], description: "Add one table row" },
-  { path: ["table", "add-rows"], script: "tableData.ts", fixedArgs: ["--action", "add-rows"], description: "Add table rows" },
-  { path: ["table", "update-row"], script: "tableData.ts", fixedArgs: ["--action", "update-row"], description: "Update one table row" },
-  { path: ["table", "update-rows"], script: "tableData.ts", fixedArgs: ["--action", "update-rows"], description: "Update table rows" },
-  { path: ["table", "delete-row"], script: "tableData.ts", fixedArgs: ["--action", "delete-row"], description: "Delete one table row" },
-  { path: ["table", "delete-rows"], script: "tableData.ts", fixedArgs: ["--action", "delete-rows"], description: "Delete table rows" },
-  { path: ["table", "data"], script: "tableData.ts", description: "Low-level table row script bridge" },
-  { path: ["table", "meta"], script: "upsertTableMeta.ts", description: "Create or update table metadata" },
-  { path: ["task-run"], script: "", description: "Update durable task-run state through the runner bridge" },
-
-  { path: ["agent", "list"], script: "listMyAgents.ts", description: "List owned agents" },
-  { path: ["agent", "pull"], script: "", description: "Cache an agent for local runs" },
-  { path: ["agent", "read"], script: "", description: "Read a single agent" },
-  { path: ["agent", "run"], script: "", description: "Run an agent" },
-  { path: ["agent", "update"], script: "updateAgent.ts", description: "Update agent fields" },
-  { path: ["agent", "bind-current"], script: "", description: "Bind an agent to this machine" },
-  { path: ["agent", "smoke-current"], script: "", description: "Smoke test a bound agent through this machine" },
-  { path: ["agent", "runtime-doctor"], script: "", description: "Diagnose current machine runtime compatibility" },
-  { path: ["agent", "unpublish"], script: "unpublishAgent.ts", description: "Remove an agent's public record" },
-  { path: ["agent", "chat"], script: "", description: "Chat with an agent" },
-  { path: ["agent", "dialogs"], script: "queryAgentDialogs.ts", description: "Inspect recent dialogs for an agent" },
-  { path: ["agent", "doctor"], script: "doctorAgentWorkspace.ts", description: "Audit agent workspace health" },
-  { path: ["agent", "create-custom"], script: "createCustomCodingAgent.ts", description: "Create a custom coding agent" },
-  { path: ["agent", "create-space"], script: "createSpaceAgents.ts", description: "Create or attach shared-space agents" },
-  { path: ["agent", "setup-demo"], script: "setupDemoAgent.ts", description: "Bootstrap demo publisher agents" },
-  { path: ["agent", "supervise"], script: "runAutonomousAgent.ts", description: "Run an agent in autonomous cycles" },
-
-  { path: ["doctor", "runtime"], script: "", description: "Diagnose local-first agent runtime selection" },
-
-  { path: ["llama"], script: "llamaServerSupervisor.ts", description: "Manage the llama.cpp runtime" },
-  { path: ["model-runtime"], script: "localModelRuntimeSupervisor.ts", description: "Manage local model runtime processes" },
-  { path: ["dev"], script: "devControl.ts", description: "Manage the local dev environment" },
+  ...getInternalCommandEntries(renderHelpText),
+  ...getScriptCommandEntries(),
 ];
 
 export const GROUP_ORDER = [

package/connector-experimental/capabilities.ts

@@ -29,6 +29,7 @@ const COMMAND_CAPABILITIES: Array<[probes: CommandProbe[], capability: string]>
   ],
   [[{ command: "gemini", args: ["--version"] }], "gemini-cli"],
   [[{ command: "kimi", args: ["--version"] }], "kimi-cli"],
+  [[{ command: "agy", args: ["--help"] }], "agy-cli"],
 ];
 
 function defaultCommandExists(command: string) {

package/database/actions/common.ts

@@ -2,7 +2,8 @@
 
 import pino from "pino";
 import { getIsDesktopApp } from "app/utils/env";
-import { API_ENDPOINTS, NOLO_CLUSTER_SERVERS } from "../config";
+import { fetchWithTransientReadRetry } from "app/utils/retryFetch";
+import { API_ENDPOINTS, NOLO_CLUSTER_SERVERS, normalizeKnownServerOrigin } from "../config";
 
 // RN 下 pino 的 browser 写法可能有兼容性问题
 // 使用简单的 console 封装作为 fallback
@@ -23,7 +24,7 @@ export const logger = isRN ? {
   // },
 });
 const normalizeServer = (server: string): string =>
-  server.trim().replace(/\/+$/, "");
+  normalizeKnownServerOrigin(server) ?? server.trim().replace(/\/+$/, "");
 const isNoloClusterServer = (server: string): boolean =>
   /^https?:\/\/(?:us\.)?nolo\.chat$/i.test(normalizeServer(server));
 
@@ -202,7 +203,7 @@ export const fetchFromServer = async (
   signal?.addEventListener("abort", onExternalAbort);
 
   try {
-    const res = await fetch(
+    const res = await fetchWithTransientReadRetry(
       `${server}${buildReadUrl(dbKey)}`,
       {
         signal: controller.signal as any,

package/database/config.ts

@@ -8,6 +8,25 @@ export const SERVERS = {
 } as const;
 export const NOLO_CLUSTER_SERVERS = Object.values(SERVERS);
 
+const LEGACY_SERVER_ORIGIN_MAP: Record<string, string> = {
+  "https://nolotus.com": SERVERS.MAIN,
+  "https://www.nolotus.com": SERVERS.MAIN,
+  "https://us.nolotus.com": SERVERS.US,
+  "https://www.us.nolotus.com": SERVERS.US,
+};
+
+export const normalizeKnownServerOrigin = (server: unknown): string | null => {
+  if (typeof server !== "string" || server.trim().length === 0) return null;
+  const trimmed = server.trim();
+  let origin: string;
+  try {
+    origin = new URL(trimmed).origin;
+  } catch {
+    origin = trimmed.replace(/\/+$/, "");
+  }
+  return LEGACY_SERVER_ORIGIN_MAP[origin.toLowerCase()] ?? origin;
+};
+
 export const API_ENDPOINTS = {
   DATABASE: `${API_VERSION}/db`,
   SHARE: `${API_VERSION}/share`,

package/database/server/coreDataProxy.ts

@@ -9,7 +9,7 @@ const normalizeOrigin = (value: string | URL | null | undefined): string => {
   }
 };
 
-const getDbKeyForOperation = (args: {
+const getDbKeyForOperation = (args: {
   operation: string;
   pathname: string;
   req: { body?: Record<string, any> };
@@ -26,10 +26,32 @@ const getDbKeyForOperation = (args: {
       return typeof req.body?.customKey === "string" ? req.body.customKey : null;
     default:
       return null;
-  }
-};
-
-export async function maybeProxyDatabaseRequestToCore(args: {
+  }
+};
+
+export function resolveCoreDataProxyTarget(args: {
+  dbKey: string;
+  requestUrl?: string | URL | null;
+  coreBaseUrl?: string | null;
+}): string | null {
+  const coreBaseUrl = normalizeOrigin(args.coreBaseUrl);
+  if (!coreBaseUrl) {
+    return null;
+  }
+
+  const requestOrigin = normalizeOrigin(args.requestUrl);
+  if (requestOrigin && requestOrigin === coreBaseUrl) {
+    return null;
+  }
+
+  if (classifyCoreDataKey(args.dbKey).owner !== "core") {
+    return null;
+  }
+
+  return coreBaseUrl;
+}
+
+export async function maybeProxyDatabaseRequestToCore(args: {
   req: {
     method?: string;
     url?: string | URL;
@@ -40,27 +62,22 @@ export async function maybeProxyDatabaseRequestToCore(args: {
   search: string;
   coreBaseUrl?: string | null;
   fetchImpl?: typeof fetch;
-}): Promise<Response | null> {
-  const { req, pathname, search, fetchImpl = fetch } = args;
-  const coreBaseUrl = normalizeOrigin(args.coreBaseUrl);
-  if (!coreBaseUrl) {
-    return null;
-  }
-
-  const requestOrigin = normalizeOrigin(req.url);
-  if (requestOrigin && requestOrigin === coreBaseUrl) {
-    return null;
-  }
-
-  const operation = pathname.slice("/api/v1/db/".length).split("/")[0] ?? "";
-  const dbKey = getDbKeyForOperation({ operation, pathname, req });
-  if (!dbKey) {
-    return null;
-  }
-
-  if (classifyCoreDataKey(dbKey).owner !== "core") {
-    return null;
-  }
+}): Promise<Response | null> {
+  const { req, pathname, search, fetchImpl = fetch } = args;
+  const operation = pathname.slice("/api/v1/db/".length).split("/")[0] ?? "";
+  const dbKey = getDbKeyForOperation({ operation, pathname, req });
+  if (!dbKey) {
+    return null;
+  }
+
+  const coreBaseUrl = resolveCoreDataProxyTarget({
+    dbKey,
+    requestUrl: req.url,
+    coreBaseUrl: args.coreBaseUrl,
+  });
+  if (!coreBaseUrl) {
+    return null;
+  }
 
   const headers = new Headers(req.headers ?? {});
   const init: RequestInit = {