openc3 7.0.0.pre.rc3 → 7.0.1

data/lib/openc3/utilities/running_script.rb

@@ -24,6 +24,7 @@ require 'openc3/io/stdout'
 require 'openc3/io/stderr'
 require 'childprocess'
 require 'openc3/script/suite_runner'
+require 'openc3/utilities/script'
 require 'openc3/utilities/store'
 require 'openc3/utilities/store_queued'
 require 'openc3/utilities/bucket_require'
@@ -31,6 +32,7 @@ require 'openc3/models/offline_access_model'
 require 'openc3/models/environment_model'
 require 'openc3/models/script_engine_model'
 require 'openc3/models/script_status_model'
+require 'fileutils'
 
 if not defined? RAILS_ROOT
   if ENV['RAILS_ROOT']
@@ -60,8 +62,8 @@ module OpenC3
     private
     # Define all the user input methods used in scripting which we need to broadcast to the frontend
     # Note: This list matches the list in run_script.rb:116
-    SCRIPT_METHODS = %i[ask ask_string message_box vertical_message_box combo_box prompt prompt_for_hazardous
-      prompt_for_critical_cmd metadata_input open_file_dialog open_files_dialog]
+    SCRIPT_METHODS = %i[ask ask_string message_box vertical_message_box combo_box check_box prompt prompt_for_hazardous
+      prompt_for_critical_cmd metadata_input open_file_dialog open_files_dialog open_bucket_dialog]
     SCRIPT_METHODS.each do |method|
       define_method(method) do |*args, **kwargs|
         while true
@@ -72,10 +74,21 @@ module OpenC3
             input = RunningScript.instance.user_input
             # All ask and prompt dialogs should include a 'Cancel' button
             # If they cancel we wait so they can potentially stop
-            if input == 'Cancel'
+            if input == 'COSMOS__CANCEL'
               RunningScript.instance.perform_pause
             else
-              if (method.to_s.include?('open_file'))
+              if method.to_s == 'open_bucket_dialog'
+                bucket = input['bucket']
+                path = input['path']
+                filename = input['filename']
+                # Path from bucket dialog already includes scope prefix (e.g. DEFAULT/targets/...)
+                # _get_storage_file prepends scope, so strip it from the path to avoid doubling
+                scope = RunningScript.instance.scope
+                path = path.sub(/\A#{Regexp.escape(scope)}\//, '')
+                file = _get_storage_file(path, bucket: bucket, scope: scope)
+                file.filename = filename
+                return file
+              elsif (method.to_s.include?('open_file'))
                 files = input.map do |filename|
                   file = _get_storage_file("tmp/#{filename}", scope: RunningScript.instance.scope)
                   # Set filename method we added to Tempfile in the core_ext
@@ -377,7 +390,9 @@ class RunningScript
       scope = $openc3_scope
       tags = []
     end
-    @@message_log = OpenC3::MessageLog.new("sr", File.join(RAILS_ROOT, 'log'), tags: tags, scope: scope)
+    log_dir = File.join(RAILS_ROOT, 'tmp', 'script_logs')
+    FileUtils.mkdir_p(log_dir)
+    @@message_log = OpenC3::MessageLog.new("sr", log_dir, tags: tags, scope: scope)
   end
 
   def message_log
@@ -422,7 +437,9 @@ class RunningScript
 
     process = ChildProcess.build(process_name, runner_path.to_s, running_script_id.to_s, scope)
     process.io.inherit! # Helps with debugging
-    process.cwd = File.join(RAILS_ROOT, 'scripts')
+    script_cwd = File.join(RAILS_ROOT, 'tmp', "script_#{running_script_id}")
+    FileUtils.mkdir_p(script_cwd)
+    process.cwd = script_cwd
 
     # Check for offline access token
     model = nil
@@ -1213,7 +1230,8 @@ class RunningScript
       end
       @suite_report = OpenC3::SuiteRunner.suite_results.report
       # Write out the report to a local file
-      log_dir = File.join(RAILS_ROOT, 'log')
+      log_dir = File.join(RAILS_ROOT, 'tmp', 'script_logs')
+      FileUtils.mkdir_p(log_dir)
       filename = File.join(log_dir, File.build_timestamped_filename(['sr', parts.join('__')]))
       File.open(filename, 'wb') do |file|
         file.write(OpenC3::SuiteRunner.suite_results.report)

data/lib/openc3/utilities/script.rb

@@ -0,0 +1,452 @@
+# encoding: ascii-8bit
+
+# Copyright 2022 Ball Aerospace & Technologies Corp.
+# All Rights Reserved.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See LICENSE.md for more details.
+
+# Modified by OpenC3, Inc.
+# All changes Copyright 2026, OpenC3, Inc.
+# All Rights Reserved
+#
+# This file may also be used under the terms of a commercial license
+# if purchased from OpenC3, Inc.
+
+require 'tempfile'
+require 'openc3/utilities/target_file'
+require 'openc3/utilities/running_script'
+require 'openc3/script/suite'
+require 'openc3/script/suite_runner'
+require 'openc3/tools/test_runner/test'
+
+OpenC3.require_file 'openc3/utilities/store'
+
+class Script < OpenC3::TargetFile
+  def self.all(scope, target = nil)
+    super(scope, nil, target: target) # No path matchers
+  end
+
+  def self.lock(scope, name, username)
+    name = name.split('*')[0] # Split '*' that indicates modified
+    OpenC3::Store.hset("#{scope}__script-locks", name, username)
+  end
+
+  def self.unlock(scope, name)
+    name = name.split('*')[0] # Split '*' that indicates modified
+    OpenC3::Store.hdel("#{scope}__script-locks", name)
+  end
+
+  def self.locked?(scope, name)
+    name = name.split('*')[0] # Split '*' that indicates modified
+    locked_by = OpenC3::Store.hget("#{scope}__script-locks", name)
+    locked_by ||= false
+    locked_by
+  end
+
+  def self.get_breakpoints(scope, name)
+    breakpoints = OpenC3::Store.hget("#{scope}__script-breakpoints", name.split('*')[0]) # Split '*' that indicates modified
+    return JSON.parse(breakpoints, allow_nan: true, create_additions: true) if breakpoints
+    []
+  end
+
+  def self.process_suite(name, contents, new_process: true, username: nil, scope:)
+    python = false
+    python = true if File.extname(name) == '.py'
+
+    start = Time.now
+
+    if python
+      temp = Tempfile.new(%w[suite .py])
+    else
+      temp = Tempfile.new(%w[suite .rb])
+    end
+
+    # Remove any carriage returns which ruby doesn't like
+    temp.write(contents.gsub(/\r/, ' '))
+    temp.close
+
+    # We open a new process so as to not pollute the API with require
+    success = true
+    if new_process or python
+      if python
+        runner_path = File.join(RAILS_ROOT, 'scripts', 'run_suite_analysis.py')
+        process_name = ENV['OPENC3_PYTHON_BIN'] || '/openc3/python/.venv/bin/python'
+        process = ChildProcess.build(process_name, runner_path.to_s, scope, temp.path)
+      else
+        runner_path = File.join(RAILS_ROOT, 'scripts', 'run_suite_analysis.rb')
+        process = ChildProcess.build('ruby', runner_path.to_s, scope, temp.path)
+      end
+      process.cwd = File.join(RAILS_ROOT, 'scripts')
+
+      # Check for offline access token
+      model = nil
+      model = OpenC3::OfflineAccessModel.get_model(name: username, scope: scope) if username and username != ''
+
+      # Set proper secrets for running script
+      process.environment['SECRET_KEY_BASE'] = nil
+      process.environment['OPENC3_REDIS_USERNAME'] = ENV['OPENC3_SR_REDIS_USERNAME'] || 'OPENC3_SR_REDIS_USERNAME not set'
+      process.environment['OPENC3_REDIS_PASSWORD'] = ENV['OPENC3_SR_REDIS_PASSWORD'] || 'OPENC3_SR_REDIS_PASSWORD not set'
+      process.environment['OPENC3_BUCKET_USERNAME'] = ENV['OPENC3_SR_BUCKET_USERNAME'] || 'OPENC3_SR_BUCKET_USERNAME not set'
+      process.environment['OPENC3_BUCKET_PASSWORD'] = ENV['OPENC3_SR_BUCKET_PASSWORD'] || 'OPENC3_SR_BUCKET_PASSWORD not set'
+      process.environment['OPENC3_SR_REDIS_USERNAME'] = nil
+      process.environment['OPENC3_SR_REDIS_PASSWORD'] = nil
+      process.environment['OPENC3_SR_BUCKET_USERNAME'] = nil
+      process.environment['OPENC3_SR_BUCKET_PASSWORD'] = nil
+      process.environment['OPENC3_API_CLIENT'] = ENV['OPENC3_API_CLIENT'] || 'api'
+      if model and model.offline_access_token
+        auth = OpenC3::OpenC3KeycloakAuthentication.new(ENV['OPENC3_KEYCLOAK_URL'])
+        valid_token = auth.get_token_from_refresh_token(model.offline_access_token)
+        if valid_token
+          process.environment['OPENC3_API_TOKEN'] = model.offline_access_token
+        else
+          model.offline_access_token = nil
+          model.update
+          raise "offline_access token invalid for script"
+        end
+      else
+        process.environment['OPENC3_API_USER'] = ENV['OPENC3_API_USER'] || nil
+        if ENV['OPENC3_SERVICE_PASSWORD']
+          process.environment['OPENC3_API_PASSWORD'] = ENV['OPENC3_SERVICE_PASSWORD']
+        else
+          # The viewer user doesn't have an offline access token (because they can't run scripts)
+          # but they still want to be able to view suite files
+          # Since processing a suite file requires running it they won't get the Suite chrome
+          # so return nothing here and allow Script Runner to simply view the suite file
+          return '', '', false
+        end
+      end
+      process.environment['GEM_HOME'] = ENV['GEM_HOME'] || '/gems'
+      process.environment['PYTHONUSERBASE'] = ENV['PYTHONUSERBASE'] || '/gems/python_packages'
+      # Preserve PYTHONPATH to ensure Python can find both UV venv and user packages
+      process.environment['PYTHONPATH'] = ENV['PYTHONPATH'] || '.'
+
+      # Spawned process should not be controlled by same Bundler constraints as spawning process
+      ENV.each do |key, _value|
+        if key =~ /^BUNDLE/
+          process.environment[key] = nil
+        end
+      end
+      process.environment['RUBYOPT'] = nil # Removes loading bundler setup
+      process.environment['OPENC3_SCOPE'] = scope
+
+      stdout = Tempfile.new("child-stdout")
+      stdout.sync = true
+      stderr = Tempfile.new("child-stderr")
+      stderr.sync = true
+      process.io.stdout = stdout
+      process.io.stderr = stderr
+      process.start
+      process.wait
+      stdout.rewind
+      stdout_results = stdout.read
+      stdout.close
+      stdout.unlink
+      stderr.rewind
+      stderr_results = stderr.read
+      stderr.close
+      stderr.unlink
+      success = process.exit_code == 0
+    else
+      require temp.path
+      stdout_results = OpenC3::SuiteRunner.build_suites.as_json().to_json(allow_nan: true)
+    end
+    temp.delete
+    puts "Processed #{name} in #{Time.now - start} seconds"
+    # Make sure we're getting the last line which should be the suite
+    puts "Stdout Results:#{stdout_results}:"
+    puts "Stderr Results:#{stderr_results}:"
+    stdout_results = stdout_results.split("\n")[-1] if stdout_results
+    return stdout_results, stderr_results, success
+  end
+
+  def self.create(params)
+    existing = body(params[:scope], params[:name])
+    # Commit if there is no existing or something has changed
+    if existing.nil? or existing != params[:text]
+      super(params[:scope], params[:name], params[:text])
+    end
+    breakpoints = params[:breakpoints]
+    if breakpoints
+      if breakpoints.empty?
+        OpenC3::Store.hdel("#{params[:scope]}__script-breakpoints", params[:name])
+      else
+        OpenC3::Store.hset("#{params[:scope]}__script-breakpoints", params[:name],
+          breakpoints.as_json().to_json(allow_nan: true))
+      end
+    end
+  end
+
+  def self.delete_temp(scope)
+    files = super(scope)
+    files.each do |name|
+      # Remove any breakpoints associated with the temp files
+      OpenC3::Store.hdel("#{scope}__script-breakpoints", "#{TEMP_FOLDER}/#{File.basename(name)}")
+    end
+  end
+
+  def self.destroy(scope, name)
+    super(scope, name)
+    OpenC3::Store.hdel("#{scope}__script-breakpoints", name)
+  end
+
+  def self.run(
+    scope,
+    name,
+    suite_runner = nil,
+    disconnect = false,
+    environment = nil,
+    user_full_name = nil,
+    username = nil,
+    line_no = nil,
+    end_line_no = nil
+  )
+    RunningScript.spawn(scope, name, suite_runner, disconnect, environment, user_full_name, username, line_no, end_line_no)
+  end
+
+  def self.instrumented(filename, text)
+    language = detect_language(text, filename)
+    if language == 'ruby'
+      return {
+        'title' => 'Instrumented Script',
+        'description' =>
+          RunningScript.instrument_script(
+            text,
+            filename,
+            true,
+          ).split("\n").as_json().to_json(allow_nan: true),
+      }
+    elsif language == 'python'
+      start = Time.now
+      temp = Tempfile.new(%w[instrument .py])
+      temp.write(text)
+      temp.close
+
+      runner_path = File.join(RAILS_ROOT, 'scripts', 'run_instrument.py')
+      process_name = ENV['OPENC3_PYTHON_BIN'] || '/openc3/python/.venv/bin/python'
+      process = ChildProcess.build(process_name, runner_path.to_s, temp.path)
+      process.cwd = File.join(RAILS_ROOT, 'scripts')
+
+      stdout = Tempfile.new("child-stdout")
+      stdout.sync = true
+      stderr = Tempfile.new("child-stderr")
+      stderr.sync = true
+      process.io.stdout = stdout
+      process.io.stderr = stderr
+      process.start
+      process.wait
+      stdout.rewind
+      stdout_results = stdout.read
+      stdout.close
+      stdout.unlink
+      stderr.rewind
+      stderr_results = stderr.read
+      stderr.close
+      stderr.unlink
+      success = process.exit_code == 0
+      puts "Processed Instrumenting #{filename} in #{Time.now - start} seconds"
+      # Make sure we're getting the last line which should be the suite
+      puts "Stdout Results:#{stdout_results}:"
+      puts "Stderr Results:#{stderr_results}:"
+      # stdout_results = stdout_results.split("\n")[-1] if stdout_results
+
+      if success
+        return {
+          'title' => 'Instrumented Script',
+          'description' =>
+            stdout_results.to_s.split("\n").as_json().to_json(allow_nan: true),
+        }
+      else
+        return {
+          'title' => 'Error Instrumenting Script',
+          'description' =>
+            (stdout_results.to_s + stderr_results.to_s).split("\n").as_json().to_json(allow_nan: true),
+        }
+      end
+    else
+      return {
+        'title' => 'Instrumenting Not Supported',
+        'description' => ['Only Ruby and Python Support Viewing Instrumentation'].as_json.to_json,
+      }
+    end
+  end
+
+  def self.detect_language(text, filename = nil)
+    if filename
+      extension = File.extname(filename)
+      if extension == '.rb'
+        return 'ruby'
+      elsif extension == '.py'
+        return 'python'
+      elsif extension.length > 0
+        return 'other'
+      end
+    end
+
+    return 'ruby' if text =~ /^\s*(require|load|puts) /
+    return 'python' if text =~ /^\s*(import|from) /
+    return 'ruby' if text =~ /^\s*end\s*$/
+    return 'python' if text =~ /^\s*(if|def|while|else|elif|class).*:\s*$/
+    return 'ruby' # otherwise guess Ruby
+  end
+
+  def self.mnemonics(filename, text)
+    # Ruby and Python are currently handled in-browser
+    # Script Engine Possibly
+    extension = File.extname(filename).to_s.downcase
+    script_engine_model = OpenC3::ScriptEngineModel.get_model(name: extension, scope: 'DEFAULT')
+    if script_engine_model
+      script_engine = script_engine_model.filename
+      if File.extname(script_engine).to_s.downcase == '.py'
+        process_name = ENV['OPENC3_PYTHON_BIN'] || '/openc3/python/.venv/bin/python'
+        runner_path = File.join(RAILS_ROOT, 'scripts', 'script_engine_cmd.py')
+      else
+        process_name = 'ruby'
+        runner_path = File.join(RAILS_ROOT, 'scripts', 'script_engine_cmd.rb')
+      end
+
+      tf = nil
+      begin
+        tf = Tempfile.new((['mnemonics', extension]))
+        tf.write(text)
+        tf.close()
+        results, status = Open3.capture2e("#{process_name} \"#{runner_path}\" mnemonic_check \"#{tf.path}\"")
+        lines = []
+        if results and results.length > 0
+          results.each_line do |line|
+            lines << line
+          end
+          return(
+            { 'title' => 'Mnemonics Check Failed', 'description' => lines.as_json().to_json(allow_nan: true) }
+          )
+        else
+          return(
+            {
+              'title' => 'Mnemonics Check Successful',
+              'description' => ["Mnemonics OK"].as_json().to_json(allow_nan: true),
+            }
+          )
+        end
+      ensure
+        tf.unlink if tf
+      end
+    else
+      raise "Unsupported script file type: #{extension}"
+    end
+  end
+
+  def self.syntax(filename, text)
+    if text.nil?
+      return(
+        { 'title' => 'Syntax Check Failed', 'description' => 'no text passed' }
+      )
+    end
+    language = detect_language(text, filename)
+    if language == 'ruby'
+      check_process = IO.popen('ruby -c -rubygems 2>&1', 'r+')
+      check_process.write("require 'openc3'; require 'openc3/script'; " + text)
+      check_process.close_write
+      results = check_process.readlines
+      check_process.close
+      if results
+        if results.any?(/Syntax OK/)
+          return(
+            {
+              'title' => 'Syntax Check Successful',
+              'description' => results.as_json().to_json(allow_nan: true),
+            }
+          )
+        else
+          # Results is an array of strings like this: ":2: syntax error ..."
+          # Normally the procedure comes before the first colon but since we
+          # are writing to the process this is blank so we throw it away
+          results.map! { |result| result.split(':')[1..-1].join(':') }
+          return(
+            { 'title' => 'Syntax Check Failed', 'description' => results.as_json().to_json(allow_nan: true) }
+          )
+        end
+      else
+        return(
+          {
+            'title' => 'Syntax Check Exception',
+            'description' => 'Ruby syntax check unexpectedly returned nil',
+          }
+        )
+      end
+    elsif language == 'python'
+      # Python
+      tf = nil
+      begin
+        tf = Tempfile.new((['syntax', '.py']))
+        tf.write(text)
+        tf.close()
+        process_name = ENV['OPENC3_PYTHON_BIN'] || '/openc3/python/.venv/bin/python'
+        results, status = Open3.capture2e("#{process_name} -m py_compile #{tf.path}")
+        lines = []
+        success = status.respond_to?(:success?) ? status.success? : status == 0
+        if !success || (results and results.length > 0)
+          results.each_line do |line|
+            lines << line
+          end
+          lines << "Syntax Error" if lines.empty?
+          return(
+            { 'title' => 'Syntax Check Failed', 'description' => lines.as_json().to_json(allow_nan: true) }
+          )
+        else
+          return(
+            {
+              'title' => 'Syntax Check Successful',
+              'description' => ["Syntax OK"].as_json().to_json(allow_nan: true),
+            }
+          )
+        end
+      ensure
+        tf.unlink if tf
+      end
+    else
+      # Script Engine Possibly
+      extension = File.extname(filename).to_s.downcase
+      script_engine_model = OpenC3::ScriptEngineModel.get_model(name: extension, scope: 'DEFAULT')
+      if script_engine_model
+        script_engine = script_engine_model.filename
+        if File.extname(script_engine).to_s.downcase == '.py'
+          process_name = ENV['OPENC3_PYTHON_BIN'] || '/openc3/python/.venv/bin/python'
+          runner_path = File.join(RAILS_ROOT, 'scripts', 'script_engine_cmd.py')
+        else
+          process_name = 'ruby'
+          runner_path = File.join(RAILS_ROOT, 'scripts', 'script_engine_cmd.rb')
+        end
+
+        tf = nil
+        begin
+          tf = Tempfile.new((['syntax', extension]))
+          tf.write(text)
+          tf.close()
+          results, status = Open3.capture2e("#{process_name} \"#{runner_path}\" syntax_check \"#{tf.path}\"")
+          lines = []
+          if results and results.length > 0
+            results.each_line do |line|
+              lines << line
+            end
+            return(
+              { 'title' => 'Syntax Check Failed', 'description' => lines.as_json().to_json(allow_nan: true) }
+            )
+          else
+            return(
+              {
+                'title' => 'Syntax Check Successful',
+                'description' => ["Syntax OK"].as_json().to_json(allow_nan: true),
+              }
+            )
+          end
+        ensure
+          tf.unlink if tf
+        end
+      else
+        raise "Unsupported script file type: #{extension}"
+      end
+    end
+  end
+end

data/lib/openc3/utilities/secrets.rb

@@ -47,7 +47,7 @@ module OpenC3
         if secret.length < 3
           raise ArgumentError, "Secret must have at least 3 items (type, key, data), got #{secret.length}"
         end
-        type, key, data, secret_store = secret
+        type, key, data, _secret_store = secret
         case type
         when 'ENV'
           @local_secrets[key] = ENV[data]

data/lib/openc3/version.rb

@@ -1,14 +1,14 @@
 # encoding: ascii-8bit
 
-OPENC3_VERSION = '7.0.0-rc3'
+OPENC3_VERSION = '7.0.1'
 module OpenC3
   module Version
     MAJOR = '7'
     MINOR = '0'
-    PATCH = '0'
-    OTHER = 'pre.rc3'
-    BUILD = '3c2c659a79585f3881e8878d8013b8a1b9fd0bb9'
+    PATCH = '1'
+    OTHER = ''
+    BUILD = '665de79cef884b8d470b08817fd4a1fb538fb187'
   end
-  VERSION = '7.0.0-rc3'
-  GEM_VERSION = '7.0.0.pre.rc3'
+  VERSION = '7.0.1'
+  GEM_VERSION = '7.0.1'
 end

data/templates/conversion/conversion.py

@@ -5,14 +5,6 @@ from openc3.conversions.conversion import Conversion
 # Custom conversion class
 # See https://docs.openc3.com/docs/configuration/conversions
 class <%= conversion_class %>(Conversion):
-    def __init__(self):
-        super().__init__()
-        # Should be one of 'INT', 'UINT', 'FLOAT', 'STRING', 'BLOCK'
-        self.converted_type = 'STRING'
-        # Size of the converted type in bits
-        # Use 0 for 'STRING' or 'BLOCK' where the size can be variable
-        self.converted_bit_size = 0
-
     # @param value [Object] Value based on the item definition. This could be
     #   a string, integer, float, or array of values.
     # @param packet [Packet] The packet object where the conversion is defined

data/templates/conversion/conversion.rb

@@ -5,17 +5,6 @@ module OpenC3
   # Custom conversion class
   # See https://docs.openc3.com/docs/configuration/conversions
   class <%= conversion_class %> < Conversion
-    def initialize
-      super()
-      # Should be one of :INT, :UINT, :FLOAT, :STRING, :BLOCK
-      @converted_type = :STRING
-      # Size of the converted type in bits
-      # Use 0 for :STRING or :BLOCK where the size can be variable
-      @converted_bit_size = 0
-      # return the arguments used
-      @params = nil
-    end
-
     # @param value [Object] Value based on the item definition. This could be
     #   a string, integer, float, or array of values.
     # @param packet [Packet] The packet object where the conversion is defined

data/templates/tool_angular/package.json

@@ -1,6 +1,6 @@
 {
   "name": "<%= tool_name %>",
-  "version": "7.0.0-rc3",
+  "version": "7.0.1",
   "scripts": {
     "ng": "ng",
     "start": "ng serve",
@@ -23,7 +23,7 @@
     "@angular/platform-browser-dynamic": "^18.2.6",
     "@angular/router": "^18.2.6",
     "@astrouxds/astro-web-components": "^7.24.0",
-    "@openc3/js-common": "6.10.4",
+    "@openc3/js-common": "7.0.1",
     "rxjs": "~7.8.0",
     "single-spa": "^5.9.5",
     "single-spa-angular": "^9.2.0",

data/templates/tool_react/package.json

@@ -16,7 +16,7 @@
     "@emotion/react": "^11.13.3",
     "@emotion/styled": "^11.11.0",
     "@mui/material": "^6.1.1",
-    "@openc3/js-common": "6.10.4",
+    "@openc3/js-common": "7.0.1",
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
     "single-spa-react": "^5.1.4"

data/templates/tool_svelte/package.json

@@ -12,7 +12,7 @@
   },
   "dependencies": {
     "@astrouxds/astro-web-components": "^7.24.0",
-    "@openc3/js-common": "6.10.4",
+    "@openc3/js-common": "7.0.1",
     "@smui/button": "^7.0.0",
     "@smui/common": "^7.0.0",
     "@smui/card": "^7.0.0",

data/templates/tool_vue/package.json

@@ -1,6 +1,6 @@
 {
   "name": "<%= tool_name %>",
-  "version": "7.0.0-rc3",
+  "version": "7.0.1",
   "private": true,
   "type": "module",
   "scripts": {
@@ -11,8 +11,8 @@
   },
   "dependencies": {
     "@astrouxds/astro-web-components": "^7.24.0",
-    "@openc3/js-common": "6.10.4",
-    "@openc3/vue-common": "6.10.4",
+    "@openc3/js-common": "7.0.1",
+    "@openc3/vue-common": "7.0.1",
     "axios": "^1.7.7",
     "date-fns": "^4.1.0",
     "lodash": "^4.17.21",
@@ -22,7 +22,6 @@
   "devDependencies": {
     "@vitejs/plugin-vue": "^6.0.1",
     "@vue/eslint-config-prettier": "^9.0.0",
-    "@vue/test-utils": "^2.4.6",
     "eslint": "^9.16.0",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-prettier": "^5.2.1",

data/templates/widget/package.json

@@ -1,6 +1,6 @@
 {
   "name": "<%= widget_name %>",
-  "version": "7.0.0-rc3",
+  "version": "7.0.1",
   "private": true,
   "type": "module",
   "scripts": {
@@ -8,7 +8,7 @@
   },
   "dependencies": {
     "@astrouxds/astro-web-components": "^7.24.0",
-    "@openc3/vue-common": "6.10.4",
+    "@openc3/vue-common": "7.0.1",
     "vuetify": "^3.7.1"
   },
   "devDependencies": {