@withone/cli 1.32.0 → 1.33.0

package/dist/index.js

@@ -23,6 +23,7 @@ import {
 
 // src/index.ts
 import { createRequire as createRequire2 } from "module";
+import path16 from "path";
 import { Command } from "commander";
 
 // src/commands/init.ts
@@ -73,6 +74,19 @@ function resolveConfig() {
       return { config: config2, scope: "project", path: projectPath, projectRoot, projectSlug };
     }
   }
+  const root = path.parse(process.cwd()).root;
+  let dir = path.resolve(process.cwd());
+  while (dir !== root) {
+    dir = path.dirname(dir);
+    const slug = getProjectSlug(dir);
+    const configPath = path.join(PROJECTS_DIR, slug, "config.json");
+    if (fs.existsSync(configPath)) {
+      const config2 = readConfigFile(configPath);
+      if (config2) {
+        return { config: config2, scope: "project", path: configPath, projectRoot: dir, projectSlug: slug };
+      }
+    }
+  }
   if (fs.existsSync(CONFIG_FILE)) {
     const config2 = readConfigFile(CONFIG_FILE);
     if (config2) {
@@ -847,8 +861,16 @@ async function updateCommand() {
   }
   s.stop(`Update available: v${currentVersion} \u2192 v${latestVersion}`);
   console.log(`Updating @withone/cli: v${currentVersion} \u2192 v${latestVersion}...`);
+  await new Promise((resolve) => {
+    const child = spawn("npm", ["cache", "clean", "--force"], {
+      stdio: "ignore",
+      shell: true
+    });
+    child.on("close", () => resolve());
+    child.on("error", () => resolve());
+  });
   const code = await new Promise((resolve) => {
-    const child = spawn("npm", ["install", "-g", "@withone/cli@latest", "--force"], {
+    const child = spawn("npm", ["install", "-g", `@withone/cli@${latestVersion}`, "--force"], {
       stdio: isAgentMode() ? "pipe" : "inherit",
       shell: true
     });
@@ -2874,32 +2896,32 @@ function validateStepsArray(steps, pathPrefix, errors) {
   const validTypes = FLOW_SCHEMA.stepTypes.map((st) => st.type);
   for (let i = 0; i < steps.length; i++) {
     const step = steps[i];
-    const path16 = `${pathPrefix}[${i}]`;
+    const path17 = `${pathPrefix}[${i}]`;
     if (!step || typeof step !== "object" || Array.isArray(step)) {
-      errors.push({ path: path16, message: "Step must be an object" });
+      errors.push({ path: path17, message: "Step must be an object" });
       continue;
     }
     const s = step;
     if (!s.id || typeof s.id !== "string") {
-      errors.push({ path: `${path16}.id`, message: 'Step must have a string "id"' });
+      errors.push({ path: `${path17}.id`, message: 'Step must have a string "id"' });
     }
     if (!s.name || typeof s.name !== "string") {
-      errors.push({ path: `${path16}.name`, message: 'Step must have a string "name"' });
+      errors.push({ path: `${path17}.name`, message: 'Step must have a string "name"' });
     }
     if (!s.type || !validTypes.includes(s.type)) {
-      errors.push({ path: `${path16}.type`, message: `Step type must be one of: ${validTypes.join(", ")}` });
+      errors.push({ path: `${path17}.type`, message: `Step type must be one of: ${validTypes.join(", ")}` });
       continue;
     }
     if (s.requires !== void 0) {
       if (!Array.isArray(s.requires)) {
-        errors.push({ path: `${path16}.requires`, message: '"requires" must be an array of selector strings (e.g. ["$.steps.foo.output.bar"])' });
+        errors.push({ path: `${path17}.requires`, message: '"requires" must be an array of selector strings (e.g. ["$.steps.foo.output.bar"])' });
       } else {
         for (let r = 0; r < s.requires.length; r++) {
           const sel = s.requires[r];
           if (typeof sel !== "string") {
-            errors.push({ path: `${path16}.requires[${r}]`, message: '"requires" entry must be a selector string' });
+            errors.push({ path: `${path17}.requires[${r}]`, message: '"requires" entry must be a selector string' });
           } else if (!sel.startsWith("$.")) {
-            errors.push({ path: `${path16}.requires[${r}]`, message: `"requires" entry "${sel}" must be a selector starting with "$." (e.g. "$.steps.foo.output.bar")` });
+            errors.push({ path: `${path17}.requires[${r}]`, message: `"requires" entry "${sel}" must be a selector starting with "$." (e.g. "$.steps.foo.output.bar")` });
           }
         }
       }
@@ -2907,7 +2929,7 @@ function validateStepsArray(steps, pathPrefix, errors) {
     if (s.onError && typeof s.onError === "object") {
       const oe = s.onError;
       if (!FLOW_SCHEMA.errorStrategies.includes(oe.strategy)) {
-        errors.push({ path: `${path16}.onError.strategy`, message: `Error strategy must be one of: ${FLOW_SCHEMA.errorStrategies.join(", ")}` });
+        errors.push({ path: `${path17}.onError.strategy`, message: `Error strategy must be one of: ${FLOW_SCHEMA.errorStrategies.join(", ")}` });
       }
     }
     const descriptor = getStepTypeDescriptor(s.type);
@@ -2917,14 +2939,14 @@ function validateStepsArray(steps, pathPrefix, errors) {
     if (!configObj || typeof configObj !== "object") {
       const hint = detectFlatConfigHint(s, descriptor);
       errors.push({
-        path: `${path16}.${configKey}`,
+        path: `${path17}.${configKey}`,
         message: `${capitalize(descriptor.type)} step must have a "${configKey}" config object${hint}`
       });
       continue;
     }
     const config2 = configObj;
     for (const [fieldName, fd] of Object.entries(descriptor.fields)) {
-      const fieldPath = `${path16}.${configKey}.${fieldName}`;
+      const fieldPath = `${path17}.${configKey}.${fieldName}`;
       const value = config2[fieldName];
       if (fd.required && (value === void 0 || value === null || value === "")) {
         errors.push({ path: fieldPath, message: `${capitalize(descriptor.type)} must have ${fd.type === "string" ? "a string" : fd.type === "array" ? "a" : "a"} "${fieldName}"` });
@@ -2960,24 +2982,24 @@ function validateStepsArray(steps, pathPrefix, errors) {
       const hasSource = typeof config2.source === "string" && config2.source.length > 0;
       const hasModule = typeof config2.module === "string" && config2.module.length > 0;
       if (!hasSource && !hasModule) {
-        errors.push({ path: `${path16}.${configKey}`, message: 'Code step must define either "source" (inline JS) or "module" (path to .mjs file)' });
+        errors.push({ path: `${path17}.${configKey}`, message: 'Code step must define either "source" (inline JS) or "module" (path to .mjs file)' });
       } else if (hasSource && hasModule) {
-        errors.push({ path: `${path16}.${configKey}`, message: 'Code step cannot define both "source" and "module" \u2014 pick one' });
+        errors.push({ path: `${path17}.${configKey}`, message: 'Code step cannot define both "source" and "module" \u2014 pick one' });
       }
       if (hasModule) {
         const m = config2.module;
         if (m.startsWith("/") || /^[a-zA-Z]:[\\/]/.test(m)) {
-          errors.push({ path: `${path16}.${configKey}.module`, message: "Code module path must be relative to the flow folder (no absolute paths)" });
+          errors.push({ path: `${path17}.${configKey}.module`, message: "Code module path must be relative to the flow folder (no absolute paths)" });
         } else if (m.split(/[\\/]/).includes("..")) {
-          errors.push({ path: `${path16}.${configKey}.module`, message: 'Code module path must not escape the flow folder ("..")' });
+          errors.push({ path: `${path17}.${configKey}.module`, message: 'Code module path must not escape the flow folder ("..")' });
         } else if (!m.endsWith(".mjs")) {
-          errors.push({ path: `${path16}.${configKey}.module`, message: "Code module must be a .mjs file" });
+          errors.push({ path: `${path17}.${configKey}.module`, message: "Code module must be a .mjs file" });
         }
       }
       if (hasSource) {
         const syntaxError = checkCodeSourceSyntax(config2.source);
         if (syntaxError) {
-          errors.push({ path: `${path16}.${configKey}.source`, message: `Syntax error in code step: ${syntaxError}` });
+          errors.push({ path: `${path17}.${configKey}.source`, message: `Syntax error in code step: ${syntaxError}` });
         }
       }
     }
@@ -3012,16 +3034,16 @@ function validateStepIds(flow2) {
   function collectIds(steps, pathPrefix) {
     for (let i = 0; i < steps.length; i++) {
       const step = steps[i];
-      const path16 = `${pathPrefix}[${i}]`;
+      const path17 = `${pathPrefix}[${i}]`;
       if (seen.has(step.id)) {
-        errors.push({ path: `${path16}.id`, message: `Duplicate step ID: "${step.id}"` });
+        errors.push({ path: `${path17}.id`, message: `Duplicate step ID: "${step.id}"` });
       } else {
         seen.add(step.id);
       }
       for (const { configKey, fieldName } of nestedKeys) {
         const config2 = step[configKey];
         if (config2 && Array.isArray(config2[fieldName])) {
-          collectIds(config2[fieldName], `${path16}.${configKey}.${fieldName}`);
+          collectIds(config2[fieldName], `${path17}.${configKey}.${fieldName}`);
         }
       }
     }
@@ -3069,7 +3091,7 @@ function validateSelectorReferences(flow2) {
     }
     return selectors;
   }
-  function checkSelectors(selectors, path16, precedingStepIds) {
+  function checkSelectors(selectors, path17, precedingStepIds) {
     for (const selector of selectors) {
       const parts = selector.split(".");
       if (parts.length < 3) continue;
@@ -3077,15 +3099,15 @@ function validateSelectorReferences(flow2) {
       if (root === "input") {
         const inputName = parts[2];
         if (!inputNames.has(inputName)) {
-          errors.push({ path: path16, message: `Selector "${selector}" references undefined input "${inputName}"` });
+          errors.push({ path: path17, message: `Selector "${selector}" references undefined input "${inputName}"` });
         }
       } else if (root === "steps") {
         const stepId = parts[2].replace(/[\[\]]/g, "").split(/[\[\]]/)[0];
         if (!allStepIds.has(stepId)) {
-          errors.push({ path: path16, message: `Selector "${selector}" references undefined step "${stepId}"` });
+          errors.push({ path: path17, message: `Selector "${selector}" references undefined step "${stepId}"` });
         } else if (precedingStepIds && !precedingStepIds.has(stepId)) {
           errors.push({
-            path: path16,
+            path: path17,
             message: `Selector "${selector}" references step "${stepId}" which is declared after the current step. Steps execute in declaration order, so this will always resolve to undefined at runtime \u2014 move the dependency earlier in the steps array.`
           });
         }
@@ -3093,20 +3115,20 @@ function validateSelectorReferences(flow2) {
     }
   }
   const EXPRESSION_FIELDS = /* @__PURE__ */ new Set(["condition.expression", "while.condition"]);
-  function checkOperatorsInSelectorField(value, path16) {
+  function checkOperatorsInSelectorField(value, path17) {
     if (typeof value === "string" && value.startsWith("$.")) {
       if (value.includes("||")) {
-        errors.push({ path: path16, message: `Selector "${value}" contains unsupported operator "||". Selectors in data fields use dot-path resolution, not JS evaluation. Use the "default" field on the input definition instead, or use a "code" step for complex expressions.` });
+        errors.push({ path: path17, message: `Selector "${value}" contains unsupported operator "||". Selectors in data fields use dot-path resolution, not JS evaluation. Use the "default" field on the input definition instead, or use a "code" step for complex expressions.` });
       } else if (value.includes("&&")) {
-        errors.push({ path: path16, message: `Selector "${value}" contains unsupported operator "&&". Selectors in data fields use dot-path resolution, not JS evaluation. Use a "condition" step or "code" step for complex expressions.` });
+        errors.push({ path: path17, message: `Selector "${value}" contains unsupported operator "&&". Selectors in data fields use dot-path resolution, not JS evaluation. Use a "condition" step or "code" step for complex expressions.` });
       }
     } else if (value && typeof value === "object" && !Array.isArray(value)) {
       for (const [k, v] of Object.entries(value)) {
-        checkOperatorsInSelectorField(v, `${path16}.${k}`);
+        checkOperatorsInSelectorField(v, `${path17}.${k}`);
       }
     } else if (Array.isArray(value)) {
       for (let i = 0; i < value.length; i++) {
-        checkOperatorsInSelectorField(value[i], `${path16}[${i}]`);
+        checkOperatorsInSelectorField(value[i], `${path17}[${i}]`);
       }
     }
   }
@@ -3174,10 +3196,10 @@ var VALID_OUTPUT_SCHEMA_TYPES = /* @__PURE__ */ new Set(["string", "number", "bo
 function isOutputSchemaObject(v) {
   return !!v && typeof v === "object" && !Array.isArray(v);
 }
-function walkOutputSchema(schema, path16) {
+function walkOutputSchema(schema, path17) {
   let current = schema;
-  for (let i = 0; i < path16.length; i++) {
-    const seg = path16[i];
+  for (let i = 0; i < path17.length; i++) {
+    const seg = path17[i];
     if (typeof current === "string") {
       return current === "unknown" || current === "object" || current === "array" ? "opaque" : "opaque";
     }
@@ -4946,8 +4968,8 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 function interpolate(template, record) {
-  return template.replace(/\{?\{(\w+(?:\.\w+)*)\}\}?/g, (_, path16) => {
-    const parts = path16.split(".");
+  return template.replace(/\{?\{(\w+(?:\.\w+)*)\}\}?/g, (_, path17) => {
+    const parts = path17.split(".");
     let value = record;
     for (const part of parts) {
       if (typeof value !== "object" || value === null) return "";
@@ -4975,8 +4997,8 @@ function deepMerge(target, source) {
   }
   return result;
 }
-function getByDotPath2(obj, path16) {
-  const parts = path16.split(".");
+function getByDotPath2(obj, path17) {
+  const parts = path17.split(".");
   let current = obj;
   for (const part of parts) {
     if (current === null || current === void 0 || typeof current !== "object") return void 0;
@@ -4985,8 +5007,8 @@ function getByDotPath2(obj, path16) {
   return current;
 }
 function stripExcludedFields(obj, paths) {
-  for (const path16 of paths) {
-    stripOnePath(obj, path16.replace(/\[\]/g, ".*").split("."));
+  for (const path17 of paths) {
+    stripOnePath(obj, path17.replace(/\[\]/g, ".*").split("."));
   }
 }
 function stripOnePath(obj, parts) {
@@ -5292,8 +5314,8 @@ function sleep2(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 function stripFields(record, paths) {
-  for (const path16 of paths) {
-    stripOnePath2(record, path16.split("."));
+  for (const path17 of paths) {
+    stripOnePath2(record, path17.split("."));
   }
 }
 function stripOnePath2(obj, parts) {
@@ -8820,6 +8842,83 @@ configSkills.command("status").description("Show installed skill version and whe
   console.log(`  current:   ${status.currentVersion}`);
   console.log(`  path:      ${status.canonicalPath}`);
 });
+config.command("reset").description("Remove the project config for the current directory (falls back to global)").option("--global", "Remove the global config instead").action(async (opts) => {
+  const resolved = resolveConfig();
+  if (opts.global) {
+    const globalPath = getGlobalConfigPath();
+    if (!globalConfigExists()) {
+      if (isAgentMode()) {
+        json({ deleted: false, reason: "No global config found" });
+      } else {
+        console.log("No global config found.");
+      }
+      return;
+    }
+    if (!isAgentMode()) {
+      const p8 = await import("@clack/prompts");
+      const confirmed = await p8.confirm({
+        message: "Delete the global config? This removes your API key for all projects without a project config.",
+        initialValue: false
+      });
+      if (p8.isCancel(confirmed) || !confirmed) {
+        console.log("Cancelled.");
+        return;
+      }
+    }
+    const fs17 = await import("fs");
+    fs17.unlinkSync(globalPath);
+    if (isAgentMode()) {
+      json({ deleted: true, scope: "global" });
+    } else {
+      console.log("Global config removed.");
+    }
+    return;
+  }
+  if (resolved.scope !== "project") {
+    if (isAgentMode()) {
+      json({ deleted: false, reason: "No project config found for this directory" });
+    } else {
+      console.log("No project config found for this directory.");
+      console.log(`Currently using: ${resolved.scope ?? "none"}`);
+    }
+    return;
+  }
+  const fs16 = await import("fs");
+  const configContent = fs16.readFileSync(resolved.path, "utf-8");
+  fs16.unlinkSync(resolved.path);
+  const next = resolveConfig();
+  fs16.mkdirSync(path16.dirname(resolved.path), { recursive: true });
+  fs16.writeFileSync(resolved.path, configContent);
+  let fallbackLabel;
+  if (next.scope === "project") {
+    fallbackLabel = `parent project config (${path16.basename(next.projectRoot)})`;
+  } else if (next.scope === "global") {
+    fallbackLabel = "global config";
+  } else {
+    fallbackLabel = "no config";
+  }
+  if (!isAgentMode()) {
+    const p8 = await import("@clack/prompts");
+    const confirmed = await p8.confirm({
+      message: `Delete project config for ${path16.basename(resolved.projectRoot)}? Will fall back to ${fallbackLabel}.`,
+      initialValue: false
+    });
+    if (p8.isCancel(confirmed) || !confirmed) {
+      console.log("Cancelled.");
+      return;
+    }
+  }
+  fs16.unlinkSync(resolved.path);
+  try {
+    fs16.rmdirSync(path16.dirname(resolved.path));
+  } catch {
+  }
+  if (isAgentMode()) {
+    json({ deleted: true, scope: "project", projectRoot: resolved.projectRoot, fallback: next.scope });
+  } else {
+    console.log(`Project config removed. Now using ${fallbackLabel}.`);
+  }
+});
 var connection = program.command("connection").description("Manage connections");
 connection.command("add [platform]").alias("a").description("Add a new connection").action(async (platform) => {
   await connectionAddCommand(platform);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@withone/cli",
-  "version": "1.32.0",
+  "version": "1.33.0",
   "description": "CLI for managing One",
   "type": "module",
   "files": [