@withone/cli 1.44.2 → 1.45.1

package/README.md

@@ -268,6 +268,7 @@ one actions execute stripe <actionId> <connectionKey> \
 | `--mock` | Return example response without making an API call |
 | `--skip-validation` | Skip input validation against the action schema |
 | `--output <path>` | Save response to a file (for binary downloads) |
+| `--no-cache` | Bypass the cached action details and re-fetch them; the fresh details still refresh the cache (execution itself is never cached) |
 
 The CLI validates required parameters (path variables, query params, body fields) against the action schema before executing. Missing params return a clear error with the flag name and description. Pass `--skip-validation` to bypass.
 
@@ -289,11 +290,11 @@ Each segment follows the same format: `<platform> <actionId> <connectionKey> [-d
 | `--parallel` | Enable parallel mode |
 | `--max-concurrency <n>` | Max concurrent actions per batch (default: 5) |
 
-Agent-mode output includes `parallel: true`, per-action `status`/`durationMs`/`response`, plus `totalDurationMs`, `succeeded`, and `failed` counts.
+Agent-mode output includes `parallel: true`, per-action `status`/`durationMs`/`response`/`_preflight` (`{"cache":"hit"|"miss"}`), plus `totalDurationMs`, `succeeded`, and `failed` counts.
 
 ### `one cache`
 
-Manage the local cache for knowledge and search responses. The CLI automatically caches `actions knowledge` and `actions search` results so repeated calls serve instantly from disk.
+Manage the local cache for knowledge and search responses. The CLI automatically caches `actions knowledge` and `actions search` results so repeated calls serve instantly from disk. `actions execute` reuses the cached action details (method, path, validation schema) for its preflight lookup, so a knowledge call followed by execute costs a single API round trip.
 
 ```bash
 one cache list                    # List all cached entries with age and status
@@ -309,11 +310,12 @@ Knowledge and search commands also support cache flags:
 one actions knowledge gmail <actionId> --no-cache       # Skip cache, fetch fresh
 one actions knowledge gmail <actionId> --cache-status   # Check cache status
 one actions search gmail "send email" --no-cache        # Skip cache for search
+one actions execute gmail <actionId> <key> --no-cache   # Fresh action-details lookup
 ```
 
 Default TTL is 1 hour. Configure via `ONE_CACHE_TTL` environment variable or `cacheTtl` in `~/.one/config.json`.
 
-Note: `actions execute` is never cached — it always hits the API fresh.
+Note: execution responses are never cached — the action always runs live. Only action metadata (docs, method, path, schema) is cached, and agent-mode execute output reports it via `"_preflight": {"cache": "hit"|"miss"}`.
 
 ### `one mem` — unified memory store
 

package/dist/chunk-77564KWS.js

@@ -0,0 +1,211 @@
+import {
+  getOpenAiApiKey,
+  readConfig,
+  setOpenAiApiKey,
+  writeConfig
+} from "./chunk-TVIZC7AC.js";
+
+// src/lib/memory/config.ts
+var DEFAULT_MEMORY_CONFIG = {
+  backend: "embedded-postgres",
+  plugins: [],
+  embedding: {
+    provider: "none",
+    model: "text-embedding-3-small",
+    dimensions: 1536
+  },
+  defaults: {
+    trackAccessOnSearch: true,
+    embedOnAdd: true,
+    embedOnSync: false
+  }
+};
+function getMemoryConfig() {
+  const config = readConfig();
+  return config?.memory ?? null;
+}
+function getMemoryConfigOrDefault() {
+  return getMemoryConfig() ?? DEFAULT_MEMORY_CONFIG;
+}
+function memoryConfigExists() {
+  return getMemoryConfig() !== null;
+}
+function updateMemoryConfig(patch, opts = {}) {
+  const config = readConfig();
+  if (!config) {
+    throw new Error("No One config found. Run `one init` first.");
+  }
+  const current = config.memory ?? DEFAULT_MEMORY_CONFIG;
+  const next = opts.replace ? patch : { ...current, ...patch };
+  config.memory = next;
+  writeConfig(config);
+  return next;
+}
+function getEmbeddingApiKey() {
+  const fromCore = getOpenAiApiKey();
+  if (fromCore) return fromCore;
+  const mem = getMemoryConfig();
+  return mem?.embedding.apiKey ?? null;
+}
+function setOpenAiApiKey2(key) {
+  setOpenAiApiKey(key);
+  if (key === "") return;
+  const mem = getMemoryConfig();
+  if (!mem) return;
+  if (mem.embedding.provider === "openai") return;
+  updateMemoryConfig({
+    ...mem,
+    embedding: { ...mem.embedding, provider: "openai" }
+  });
+}
+
+// src/lib/memory/embedding.ts
+var FETCH_TIMEOUT_MS = 3e4;
+function fetchWithTimeout(url, init, timeoutMs) {
+  const ctrl = new AbortController();
+  const t = setTimeout(() => ctrl.abort(), timeoutMs);
+  return fetch(url, { ...init, signal: ctrl.signal }).finally(() => clearTimeout(t));
+}
+async function embed(text, opts = {}) {
+  const clean = text?.trim();
+  if (!clean) return null;
+  const cfg = getMemoryConfigOrDefault();
+  if (cfg.embedding.provider !== "openai") return null;
+  const apiKey = getEmbeddingApiKey();
+  if (!apiKey) return null;
+  const model = opts.model ?? cfg.embedding.model;
+  const dimensions = cfg.embedding.dimensions;
+  for (let attempt = 0; attempt < 3; attempt++) {
+    try {
+      const res = await fetchWithTimeout("https://api.openai.com/v1/embeddings", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apiKey}`
+        },
+        body: JSON.stringify({
+          model,
+          input: clean.slice(0, 8e3),
+          dimensions
+        })
+      }, FETCH_TIMEOUT_MS);
+      if (!res.ok) {
+        if (res.status === 429 || res.status >= 500) {
+          await sleep(500 * (attempt + 1));
+          continue;
+        }
+        const body2 = await res.text();
+        throw new Error(`OpenAI embeddings ${res.status}: ${body2}`);
+      }
+      const body = await res.json();
+      const vector = body.data[0]?.embedding;
+      if (!vector || vector.length !== dimensions) {
+        throw new Error(`Unexpected embedding shape (got length ${vector?.length})`);
+      }
+      return { vector, model: `openai:${model}` };
+    } catch (err) {
+      if (attempt === 2) {
+        process.stderr.write(`[mem] embedding failed: ${err instanceof Error ? err.message : String(err)}
+`);
+        return null;
+      }
+      await sleep(500 * (attempt + 1));
+    }
+  }
+  return null;
+}
+async function embedBatch(texts, opts = {}) {
+  if (texts.length === 0) return [];
+  const cfg = getMemoryConfigOrDefault();
+  if (cfg.embedding.provider !== "openai") return texts.map(() => null);
+  const apiKey = getEmbeddingApiKey();
+  if (!apiKey) return texts.map(() => null);
+  const model = opts.model ?? cfg.embedding.model;
+  const dimensions = cfg.embedding.dimensions;
+  const active = [];
+  texts.forEach((t, i) => {
+    const clean = t?.trim();
+    if (clean) active.push({ index: i, input: clean.slice(0, 8e3) });
+  });
+  if (active.length === 0) return texts.map(() => null);
+  const result = texts.map(() => null);
+  for (let attempt = 0; attempt < 3; attempt++) {
+    try {
+      const res = await fetchWithTimeout("https://api.openai.com/v1/embeddings", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${apiKey}`
+        },
+        body: JSON.stringify({
+          model,
+          input: active.map((a) => a.input),
+          dimensions
+        })
+      }, FETCH_TIMEOUT_MS);
+      if (!res.ok) {
+        if (res.status === 429 || res.status >= 500) {
+          await sleep(500 * (attempt + 1));
+          continue;
+        }
+        const body2 = await res.text();
+        throw new Error(`OpenAI embeddings ${res.status}: ${body2}`);
+      }
+      const body = await res.json();
+      for (const item of body.data) {
+        const slot = active[item.index];
+        if (!slot) continue;
+        result[slot.index] = { vector: item.embedding, model: `openai:${model}` };
+      }
+      return result;
+    } catch (err) {
+      if (attempt === 2) {
+        process.stderr.write(`[mem] batch embedding failed: ${err instanceof Error ? err.message : String(err)}
+`);
+        return result;
+      }
+      await sleep(500 * (attempt + 1));
+    }
+  }
+  return result;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function defaultSearchableText(data, maxLen = 4e3) {
+  const parts = [];
+  const walk = (value, depth = 0) => {
+    if (value === null || value === void 0) return;
+    if (typeof value === "string" && value.trim()) {
+      parts.push(value.trim());
+      return;
+    }
+    if (typeof value === "number" || typeof value === "boolean") {
+      parts.push(String(value));
+      return;
+    }
+    if (depth > 4) return;
+    if (Array.isArray(value)) {
+      for (const v of value) walk(v, depth + 1);
+      return;
+    }
+    if (typeof value === "object") {
+      for (const v of Object.values(value)) walk(v, depth + 1);
+    }
+  };
+  walk(data);
+  const joined = parts.join(" ").replace(/\s+/g, " ").trim();
+  return joined.length > maxLen ? joined.slice(0, maxLen) : joined;
+}
+
+export {
+  DEFAULT_MEMORY_CONFIG,
+  getMemoryConfig,
+  getMemoryConfigOrDefault,
+  memoryConfigExists,
+  updateMemoryConfig,
+  setOpenAiApiKey2 as setOpenAiApiKey,
+  embed,
+  embedBatch,
+  defaultSearchableText
+};