march-cli 0.1.12 → 0.1.14

package/src/main.mjs

@@ -15,7 +15,7 @@ import { createStatusLineUpdater } from "./cli/status-line-updater.mjs";
 import { wireTuiHandlers } from "./cli/tui/tui-handlers.mjs";
 import { createMarchAuthStorage } from "./auth/storage.mjs";
 import { runLoginCommand } from "./auth/login-command.mjs";
-import { createRunner } from "./agent/runner.mjs";
+import { createRuntimeRunner } from "./cli/startup/create-runtime-runner.mjs";
 import { createCliShellRuntime } from "./shell/cli-runtime.mjs";
 import { MarkdownMemoryStore } from "./memory/markdown-store.mjs";
 import { createMarkdownMemoryTools } from "./memory/markdown-tools.mjs";
@@ -23,15 +23,14 @@ import { loadDotEnv } from "./config/dotenv.mjs";
 import { loadConfig } from "./config/loader.mjs";
 import { discoverProjectExtensionPaths } from "./extensions/discovery.mjs";
 import { loadProjectLifecycleHookManifests } from "./extensions/lifecycle-manifest.mjs";
-import { resolvePiSessionManager } from "./session/pi-manager.mjs";
 import { loadOrCreateProjectId, resumeStartupSession } from "./cli/startup/startup-session.mjs";
 import { formatStartupBanner } from "./cli/startup/startup-banner.mjs";
 import { initializeMcp } from "./mcp/index.mjs";
 import { createWebToolsFromConfig } from "./web/tools.mjs";
 import { createModelContextDumper } from "./debug/model-context-dumper.mjs";
 import { createLogger, installProcessLogHandlers } from "./debug/logger.mjs";
-import { defaultCenterMemoryPath } from "./context/center-memory.mjs";
-import { runProviderConfigCommand } from "./provider/config-command.mjs";
+import { defaultProfilePaths, ensureProfileFiles } from "./context/profiles.mjs";
+import { runProviderCommand } from "./provider/command.mjs";
 import { runWebSearchConfigCommand } from "./web/config-command.mjs";
 import { createDesktopTurnNotifier } from "./notification/desktop-notifier.mjs";
 import { registerSuperGrokOAuthProvider } from "./supergrok/oauth-provider.mjs";
@@ -49,6 +48,7 @@ export async function run(argv) {
   }
 
   const config = loadConfig(cwd);
+  const useRuntimeProcess = process.env.MARCH_RUNTIME_PROCESS !== "0";
   installNetworkEnvironment(config.network);
   if (args.command?.name === "login") {
     try {
@@ -60,11 +60,12 @@ export async function run(argv) {
       return 1;
     }
   }
-
-  if (args.command?.name === "provider" || args.command?.name === "websearch") {
-    const command = args.command.name === "provider" ? runProviderConfigCommand : runWebSearchConfigCommand;
-    if (args.providerConfig) return await command({ homeDir: homedir() });
-    process.stderr.write(`Usage: march ${args.command.name} --config\n`);
+  if (args.command?.name === "provider") {
+    return await runProviderCommand(args);
+  }
+  if (args.command?.name === "websearch") {
+    if (args.providerConfig) return await runWebSearchConfigCommand({ homeDir: homedir() });
+    process.stderr.write("Usage: march websearch --config\n");
     return 1;
   }
 
@@ -103,14 +104,16 @@ export async function run(argv) {
   const modeState = createModeState();
   const namespace = loadOrCreateProjectId(projectMarchDir);
   const memoryRoot = resolveMemoryRoot(config.memoryRoot, stateRoot);
-  const centerMemoryPath = defaultCenterMemoryPath();
+  const profilePaths = defaultProfilePaths();
+  ensureProfileFiles(profilePaths);
   const memoryStore = new MarkdownMemoryStore({ root: memoryRoot });
   const memoryTools = createMarkdownMemoryTools(memoryStore);
   const currentProject = basename(cwd);
   const shellRuntime = args.shellRuntime ? createCliShellRuntime({ cwd }) : null;
 
-  // MCP: connect to configured MCP servers
-  const mcpInit = await initializeMcp({ projectDir: cwd });
+  const mcpInit = useRuntimeProcess
+    ? { clientManager: null, mcpTools: [], mcpInjections: [], errors: [] }
+    : await initializeMcp({ projectDir: cwd });
   const { clientManager: mcpClientManager, mcpTools, mcpInjections } = mcpInit;
   for (const { server, error } of mcpInit.errors) {
     if (args.json) {
@@ -159,17 +162,33 @@ export async function run(argv) {
   let turnRunning = false;
   let refreshStatusBar = null;
 
-  const runner = await createRunner({
+  const runnerOptions = {
     cwd,
     modelId: model,
     provider,
     serviceTier,
-
     providers: config.providers,
+    config,
     stateRoot,
-    ui,
     memoryRoot,
-    centerMemoryPath,
+    profilePaths,
+    namespace,
+    projectMarchDir,
+    extensionPaths,
+    permissionMode,
+    shellRuntime: Boolean(shellRuntime),
+    lifecycleHooks: lifecycleManifests.hooks,
+    lifecycleDiagnostics: lifecycleManifests.diagnostics,
+    modelContextDumper: {
+      enabled: args.dumpContext,
+      rootDir: contextDumpRoot,
+    },
+  };
+
+  const runner = await createRuntimeRunner({
+    useRuntimeProcess,
+    runnerOptions,
+    ui,
     memoryStore,
     memoryTools,
     shellRuntime,
@@ -177,29 +196,14 @@ export async function run(argv) {
     mcpInjections,
     mcpClientManager,
     webTools,
-    namespace,
-    projectMarchDir,
-    extensionPaths,
-    sessionManager: resolvePiSessionManager({
-      cwd,
-      projectMarchDir,
-      enabled: usePiSessions,
-    }),
-    useRuntimeHost: usePiRuntimeHost,
-    syncPiSidecar: usePiSessions || usePiRuntimeHost,
-    lifecycleHooks: lifecycleManifests.hooks,
-    lifecycleDiagnostics: lifecycleManifests.diagnostics,
+    usePiSessions,
+    usePiRuntimeHost,
     authStorage: authConfig.authStorage,
-    maxTurns: config.maxTurns ?? undefined,
-    trimBatch: config.trimBatch ?? undefined,
-    hostedTools: config.hostedTools,
     permissionController,
     modelContextDumper,
     turnNotifier,
     logger,
-    onModelPayload: ({ estimatedTokens }) => {
-      refreshStatusBar?.({ contextTokens: estimatedTokens });
-    },
+    refreshStatusBar: (...args) => refreshStatusBar?.(...args),
   });
 
   refreshStatusBar = createStatusLineUpdater({
@@ -209,7 +213,10 @@ export async function run(argv) {
     sessionSource,
     getMode: () => modeState.get(),
   });
-  refreshStatusBar();
+  const initialContextTokens = typeof runner.estimateContextTokens === "function"
+    ? await runner.estimateContextTokens("")
+    : null;
+  refreshStatusBar(initialContextTokens ? { contextTokens: initialContextTokens } : undefined);
 
   wireTuiHandlers({
     ui,

package/src/provider/accept-command.mjs

@@ -0,0 +1,89 @@
+import { globalConfigJsonPath, readConfigJson, upsertSharedProviderProfile } from "../config/config-json.mjs";
+import { selectWithKeyboard } from "../cli/input/select-with-keyboard.mjs";
+import { hasApiKey, parseProviderShareToken } from "./share-payload.mjs";
+
+export async function runProviderAcceptCommand({
+  homeDir,
+  token,
+  input = process.stdin,
+  output = process.stdout,
+  select = selectWithKeyboard,
+} = {}) {
+  if (!token) {
+    output.write("Usage: march provider accept <march-provider-v1-token>\n");
+    return 1;
+  }
+
+  let payload;
+  try {
+    payload = parseProviderShareToken(token);
+  } catch (error) {
+    output.write(`Invalid provider share token: ${error.message}\n`);
+    return 1;
+  }
+
+  output.write(formatImportPreview(payload));
+  const path = globalConfigJsonPath(homeDir);
+  const config = readConfigJson(path);
+  const providers = config.providers && typeof config.providers === "object" && !Array.isArray(config.providers) ? config.providers : {};
+  if (providers[payload.providerId]) {
+    const action = await select({
+      input,
+      output,
+      message: `Provider "${payload.providerId}" already exists`,
+      items: [
+        { label: "Overwrite existing provider", value: "overwrite" },
+        { label: "Cancel", value: "cancel" },
+      ],
+    });
+    if (action !== "overwrite") {
+      output.write("Provider import cancelled.\n");
+      return 1;
+    }
+  } else {
+    const action = await select({
+      input,
+      output,
+      message: "Import provider?",
+      items: [
+        { label: "Import", value: "import" },
+        { label: "Cancel", value: "cancel" },
+      ],
+    });
+    if (action !== "import") {
+      output.write("Provider import cancelled.\n");
+      return 1;
+    }
+  }
+
+  upsertSharedProviderProfile({ path, id: payload.providerId, provider: payload.provider });
+  output.write(`Imported provider: ${payload.providerId}\n`);
+  output.write(`Config: ${path}\n`);
+  return 0;
+}
+
+export function formatImportPreview(payload) {
+  const provider = payload.provider;
+  const models = Array.isArray(provider.models) ? provider.models : [];
+  const lines = [
+    "Provider to import:",
+    `  Id: ${payload.providerId}`,
+    `  Name: ${typeof provider.name === "string" && provider.name ? provider.name : "-"}`,
+    `  Type: ${provider.type}`,
+  ];
+  if (typeof provider.baseUrl === "string" && provider.baseUrl) lines.push(`  Base URL: ${provider.baseUrl}`);
+  if (typeof provider.api === "string" && provider.api) lines.push(`  API: ${provider.api}`);
+  if (models.length) {
+    lines.push(`  Models: ${models.length}`);
+    for (const model of models.slice(0, 5)) lines.push(`    - ${formatModel(model)}`);
+    if (models.length > 5) lines.push(`    ... ${models.length - 5} more`);
+  }
+  lines.push(`  API key: ${hasApiKey(provider) ? "included" : "not included"}`);
+  lines.push("");
+  return `${lines.join("\n")}\n`;
+}
+
+function formatModel(model) {
+  if (model && typeof model === "object" && !Array.isArray(model)) return model.name || model.id || "<unnamed>";
+  return String(model);
+}

package/src/provider/command.mjs

@@ -0,0 +1,21 @@
+import { homedir } from "node:os";
+import { runProviderConfigCommand } from "./config-command.mjs";
+import { runProviderShareCommand } from "./share-command.mjs";
+import { runProviderAcceptCommand } from "./accept-command.mjs";
+
+export async function runProviderCommand(args, { homeDir = homedir(), stderr = process.stderr } = {}) {
+  if (args.providerConfig) return await runProviderConfigCommand({ homeDir });
+  if (args.command.args[0] === "share") {
+    return await runProviderShareCommand({
+      homeDir,
+      providerId: args.command.args[1],
+      includeKey: args.includeKey,
+      profileOnly: args.profileOnly,
+    });
+  }
+  if (args.command.args[0] === "accept") {
+    return await runProviderAcceptCommand({ homeDir, token: args.command.args[1] });
+  }
+  stderr.write("Usage: march provider --config | march provider share [id] | march provider accept <token>\n");
+  return 1;
+}

package/src/provider/custom-provider.mjs

@@ -52,7 +52,7 @@ function normalizeModels(providerId, models, { api, baseUrl }) {
       api: normalizeApi(providerId, model.api ?? api),
       baseUrl: typeof model.baseUrl === "string" && model.baseUrl.trim() ? model.baseUrl : baseUrl,
       reasoning: typeof model.reasoning === "boolean" ? model.reasoning : false,
-      input: normalizeInput(model.input),
+      input: normalizeInput(model.input, model.capabilities),
       cost: normalizeCost(model.cost),
       contextWindow: normalizePositiveNumber(model.contextWindow, 128000),
       maxTokens: normalizePositiveNumber(model.maxTokens, 4096),
@@ -75,9 +75,10 @@ function requireString(providerId, field, value) {
   return value;
 }
 
-function normalizeInput(input) {
-  if (!Array.isArray(input) || input.length === 0) return ["text"];
-  const normalized = input.filter((item) => item === "text" || item === "image");
+function normalizeInput(input, capabilities = null) {
+  const normalized = Array.isArray(input) ? input.filter((item) => item === "text" || item === "image") : [];
+  if ((capabilities?.images === true || capabilities?.vision === true) && !normalized.includes("image")) normalized.push("image");
+  if (!normalized.includes("text")) normalized.unshift("text");
   return normalized.length > 0 ? normalized : ["text"];
 }
 

package/src/provider/share-command.mjs

@@ -0,0 +1,79 @@
+import { globalConfigJsonPath, readConfigJson } from "../config/config-json.mjs";
+import { selectWithKeyboard } from "../cli/input/select-with-keyboard.mjs";
+import { cloneProviderForShare, createProviderShareToken, hasApiKey } from "./share-payload.mjs";
+
+export async function runProviderShareCommand({
+  homeDir,
+  providerId,
+  includeKey = false,
+  profileOnly = false,
+  input = process.stdin,
+  output = process.stdout,
+  select = selectWithKeyboard,
+} = {}) {
+  if (includeKey && profileOnly) {
+    output.write("Choose either --include-key or --profile-only, not both.\n");
+    return 1;
+  }
+
+  const config = readConfigJson(globalConfigJsonPath(homeDir));
+  const providers = normalizeProviders(config.providers);
+  const selectedProviderId = providerId ?? await selectProvider({ providers, input, output, select });
+  if (!selectedProviderId) {
+    output.write(Object.keys(providers).length ? "Provider share cancelled.\n" : "No providers configured. Run: march provider --config\n");
+    return 1;
+  }
+
+  const provider = providers[selectedProviderId];
+  if (!provider) {
+    output.write(`Provider not found: ${selectedProviderId}\n`);
+    return 1;
+  }
+
+  const includeApiKey = includeKey || (!profileOnly && await selectShareMode({ input, output, select }));
+  const sharedProvider = cloneProviderForShare(provider, { includeApiKey });
+  const token = createProviderShareToken({
+    providerId: selectedProviderId,
+    provider: sharedProvider,
+    mode: includeApiKey ? "full" : "profile-only",
+  });
+
+  output.write(`Provider: ${selectedProviderId}\n`);
+  output.write(`Mode: ${includeApiKey ? "Full config, including API key" : "Profile only, without API key"}\n`);
+  output.write(`API key: ${hasApiKey(sharedProvider) ? "included" : "not included"}\n\n`);
+  output.write(`march provider accept ${token}\n`);
+  return 0;
+}
+
+function normalizeProviders(providers) {
+  return providers && typeof providers === "object" && !Array.isArray(providers) ? providers : {};
+}
+
+async function selectProvider({ providers, input, output, select }) {
+  const items = Object.entries(providers).map(([id, provider]) => ({
+    value: id,
+    label: formatProviderLabel(id, provider),
+  }));
+  return await select({ input, output, message: "Choose provider to share", items });
+}
+
+async function selectShareMode({ input, output, select }) {
+  const mode = await select({
+    input,
+    output,
+    message: "Choose share mode",
+    items: [
+      { label: "Full config, including API key", value: "full" },
+      { label: "Profile only, without API key", value: "profile-only" },
+    ],
+  });
+  return mode === "full";
+}
+
+function formatProviderLabel(id, provider) {
+  const name = typeof provider?.name === "string" && provider.name ? provider.name : "-";
+  const type = typeof provider?.type === "string" && provider.type ? provider.type : "unknown";
+  const modelCount = Array.isArray(provider?.models) ? `${provider.models.length} model${provider.models.length === 1 ? "" : "s"}` : "built-in";
+  const key = hasApiKey(provider) ? "API key configured" : "no API key";
+  return `${id}  ${name}  ${type}  ${modelCount}  ${key}`;
+}

package/src/provider/share-payload.mjs

@@ -0,0 +1,52 @@
+const KIND = "march.provider.share";
+const VERSION = 1;
+const PREFIX = "march-provider-v1.";
+
+export function createProviderShareToken({ providerId, provider, mode }) {
+  const payload = {
+    kind: KIND,
+    version: VERSION,
+    mode,
+    containsApiKey: hasApiKey(provider),
+    providerId,
+    provider,
+  };
+  return `${PREFIX}${Buffer.from(JSON.stringify(payload), "utf8").toString("base64url")}`;
+}
+
+export function parseProviderShareToken(token) {
+  const text = String(token ?? "").trim();
+  if (!text.startsWith(PREFIX)) throw new Error(`Provider share token must start with ${PREFIX}`);
+  let payload;
+  try {
+    payload = JSON.parse(Buffer.from(text.slice(PREFIX.length), "base64url").toString("utf8"));
+  } catch {
+    throw new Error("Invalid provider share token");
+  }
+  validateProviderSharePayload(payload);
+  return payload;
+}
+
+export function cloneProviderForShare(provider, { includeApiKey }) {
+  const clone = structuredClone(provider);
+  if (!includeApiKey && clone.auth && typeof clone.auth === "object" && !Array.isArray(clone.auth)) {
+    delete clone.auth.apiKey;
+  }
+  return clone;
+}
+
+export function hasApiKey(provider) {
+  return typeof provider?.auth?.apiKey === "string" && provider.auth.apiKey.length > 0;
+}
+
+export function validateProviderSharePayload(payload) {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) throw new Error("Invalid provider share payload");
+  if (payload.kind !== KIND || payload.version !== VERSION) throw new Error("Unsupported provider share token");
+  if (typeof payload.providerId !== "string" || !payload.providerId.trim()) throw new Error("Provider share token is missing providerId");
+  validateProviderProfile(payload.provider);
+}
+
+function validateProviderProfile(provider) {
+  if (!provider || typeof provider !== "object" || Array.isArray(provider)) throw new Error("Provider share token is missing provider config");
+  if (typeof provider.type !== "string" || !provider.type.trim()) throw new Error("Provider config is missing type");
+}

package/src/supergrok/tool.mjs

@@ -13,14 +13,14 @@ export function createSuperGrokTool({ authStorage, projectMarchDir, resolveCrede
     name: "supergrok",
     label: "SuperGrok",
     description:
-      "Use SuperGrok capabilities through xAI: realtime web search, X/Twitter search, and Grok image generation. " +
-      "Default search behavior is broad and enables image/video understanding where supported. Requires SuperGrok OAuth or XAI_API_KEY.",
-    promptSnippet: "supergrok(action, query, options?) - Use SuperGrok web_search, x_search, or image_generate",
+      "Use SuperGrok for complex research tasks that would otherwise require multiple searches or source comparison. " +
+      "It is backed by an agent team that can search repeatedly, verify across sources, and synthesize an answer.",
+    promptSnippet: "supergrok(action, query, options?) - Prefer SuperGrok for complex web/X research or Grok image generation",
     promptGuidelines: [
-      "Use action=web_search for current web/news/documentation facts.",
-      "Use action=x_search for current X/Twitter posts, reactions, profiles, and threads.",
+      "Prefer action=web_search for broad, ambiguous, current, or multi-step research.",
+      "Use action=x_search for targeted X/Twitter posts, reactions, profiles, and threads.",
       "Use action=image_generate when the user asks Grok/SuperGrok to create an image.",
-      "Do not add domain, handle, or date filters unless the user asks for that narrower scope.",
+      "Use narrower tools instead for simple lookups, exact URL fetching, targeted X search, or non-Grok image generation.",
     ],
     parameters: Type.Object({
       action: Type.String({ enum: ACTIONS, description: "SuperGrok capability to invoke" }),

package/src/context/center-memory.mjs

@@ -1,14 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-
-export function defaultCenterMemoryPath() {
-  return join(homedir(), ".march", "memory", "center.md");
-}
-
-export function buildCenterMemory(path = defaultCenterMemoryPath()) {
-  if (!path || !existsSync(path)) return null;
-  const content = readFileSync(path, "utf8").trimEnd();
-  if (!content.trim()) return null;
-  return `[center_memory]\n--- ${path} ---\n${content}`;
-}